oj.uz

Submission #894119

# Submission time Handle Problem Language Result Execution time Memory
894119 2023-12-28T01:24:15 Z Olympia Hedgehog Daniyar and Algorithms (IZhO19_sortbooks) C++17
17 / 100
 3000 ms 262144 KB 
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <climits>
#include <cmath>
#include <cassert>
#include <algorithm>
using namespace std;
struct Node {
    int mx;
    int mn;
    int val;
    int l;
    int r;
    Node (int l, int r) {
        this->mx = INT_MIN, this->mn = INT_MAX, this->val = 0, this->l = l, this->r = r;
    }
};
Node id = {-1, -1};
struct MergeSortTree {
    vector<set<int>> vec;
    vector<int> v;
    void build (int dum, int tl, int tr) {
        if (tl == tr) {
            vec[dum] = {v[tl]};
            return;
        }
        build(2 * dum + 1, tl, (tl + tr)/2);
        build(2 * dum + 2, (tl + tr)/2 + 1, tr);
        std::set_union(std::begin(vec[2 * dum + 1]), std::end(vec[2 * dum + 1]),
                       std::begin(vec[2 * dum + 2]), std::end(vec[2 * dum + 2]),
                       std::inserter(vec[dum], std::begin(vec[dum])));
    }
    int query (int dum, int tl, int tr, int l, int r, int k) {
        if (tl >= l && tr <= r) {
            auto it = vec[dum].lower_bound(k);
            if (it == vec[dum].begin()) {
                return -INT_MAX;
            }
            return *(--it);
        }
        if (tl > r || l > tr) {
            return -INT_MAX;
        }
        return max(query(2 * dum + 1, tl, (tl + tr)/2, l, r, k), query(2 * dum + 2, (tl + tr)/2 + 1, tr, l, r, k));
    }
    int query (int l, int r, int k) {
        return query(0, 0, (int)vec.size()/2 - 1, l, r, k);
    }
    MergeSortTree (vector<int> v) {
        assert(__builtin_popcount(v.size()) == 1);
        this->v = v;
        vec.resize(v.size() * 2);
        build(0, 0, (int)vec.size()/2 - 1);
    }
};
struct SegmentTree {
    vector<Node> vec;
    vector<int> nodes;
    MergeSortTree ms = MergeSortTree({0});
    Node merge (Node left, Node right) {
        if (left.l == -1) {
            return right;
        }
        if (right.l == -1) {
            return left;
        }
        Node ans = Node(left.l, right.r);
        ans.mn = min(left.mn, right.mn);
        ans.mx = max(left.mx, right.mx);
        ans.val = max(left.val, right.val);
        if (right.mn < left.mx) {
            ans.val = max(ans.val, ms.query(right.l, right.r, left.mx - 1) + left.mx);
        }
        return ans;
    }
    Node query (int dum, int tl, int tr, int l, int r) {
        if (tl >= l && tr <= r) {
            return vec[dum];
        }
        if (tl > r || tr < l) {
            return id;
        }
        return merge(query(2 * dum + 1, tl, (tl + tr)/2,l, r), query(2 * dum + 2, (tl + tr)/2 + 1, tr, l, r));
    }
    int query (int l, int r) {
        return query(0, 0, (int)vec.size()/2 - 1, l, r).val;
    }
    Node build (int dum, int tl, int tr) {
        if (tl == tr) {
            vec[dum] = Node(tl, tr);
            vec[dum].mn = vec[dum].mx = nodes[tl];
            return vec[dum];
        }
        build(2 * dum + 1, tl, (tl + tr)/2);
        build(2 * dum + 2, (tl + tr)/2 + 1, tr);
        return vec[dum] = merge( build(2 * dum + 1, tl, (tl + tr)/2), build(2 * dum + 2, (tl + tr)/2 + 1, tr));
    }
    SegmentTree (vector<int> nodes) {
        this->nodes = nodes;
        int n = nodes.size();
        n = (1 << (int)log2(n)) * 2;
        vec.assign(2 * n, Node(0, 0));
        while (this->nodes.size() < vec.size()) {
            this->nodes.push_back((int)1e9);
        }
        this->ms = MergeSortTree(this->nodes);
        build(0, 0, (int)vec.size()/2 - 1);
    }
};
int main () {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n, q;
    cin >> n >> q;
    vector<int> v(n);
    for (int i = 0; i < n; i++) {
        cin >> v[i];
    }
    SegmentTree st(v);
    while (q--) {
        int l, r, k;
        cin >> l >> r >> k;
        l--, r--;
        cout << (st.query(l, r) <= k) << '\n';
    }
}

Subtask #1
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 2 ms 620 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 604 KB Output is correct
6 Correct 8 ms 860 KB Output is correct
7 Correct 8 ms 856 KB Output is correct
8 Correct 7 ms 856 KB Output is correct
9 Correct 5 ms 684 KB Output is correct
10 Correct 5 ms 604 KB Output is correct

Subtask #2
9.0 / 9.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 2 ms 620 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 604 KB Output is correct
6 Correct 8 ms 860 KB Output is correct
7 Correct 8 ms 856 KB Output is correct
8 Correct 7 ms 856 KB Output is correct
9 Correct 5 ms 684 KB Output is correct
10 Correct 5 ms 604 KB Output is correct
11 Correct 104 ms 2120 KB Output is correct
12 Correct 1567 ms 7156 KB Output is correct
13 Correct 1568 ms 7160 KB Output is correct
14 Correct 1607 ms 7292 KB Output is correct
15 Correct 1584 ms 7284 KB Output is correct
16 Correct 1254 ms 7256 KB Output is correct
17 Correct 1114 ms 6676 KB Output is correct
18 Correct 1091 ms 4392 KB Output is correct

Subtask #3
0 / 13.0

# Verdict Execution time Memory Grader output
1 Runtime error 124 ms 262144 KB Execution killed with signal 9
2 Halted 0 ms 0 KB -

Subtask #4
0 / 17.0

# Verdict Execution time Memory Grader output
1 Execution timed out 3105 ms 101308 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #5
0 / 30.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 2 ms 620 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 604 KB Output is correct
6 Correct 8 ms 860 KB Output is correct
7 Correct 8 ms 856 KB Output is correct
8 Correct 7 ms 856 KB Output is correct
9 Correct 5 ms 684 KB Output is correct
10 Correct 5 ms 604 KB Output is correct
11 Correct 104 ms 2120 KB Output is correct
12 Correct 1567 ms 7156 KB Output is correct
13 Correct 1568 ms 7160 KB Output is correct
14 Correct 1607 ms 7292 KB Output is correct
15 Correct 1584 ms 7284 KB Output is correct
16 Correct 1254 ms 7256 KB Output is correct
17 Correct 1114 ms 6676 KB Output is correct
18 Correct 1091 ms 4392 KB Output is correct
19 Runtime error 389 ms 262144 KB Execution killed with signal 9
20 Halted 0 ms 0 KB -

Subtask #6
0 / 23.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 344 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 2 ms 620 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 604 KB Output is correct
6 Correct 8 ms 860 KB Output is correct
7 Correct 8 ms 856 KB Output is correct
8 Correct 7 ms 856 KB Output is correct
9 Correct 5 ms 684 KB Output is correct
10 Correct 5 ms 604 KB Output is correct
11 Correct 104 ms 2120 KB Output is correct
12 Correct 1567 ms 7156 KB Output is correct
13 Correct 1568 ms 7160 KB Output is correct
14 Correct 1607 ms 7292 KB Output is correct
15 Correct 1584 ms 7284 KB Output is correct
16 Correct 1254 ms 7256 KB Output is correct
17 Correct 1114 ms 6676 KB Output is correct
18 Correct 1091 ms 4392 KB Output is correct
19 Runtime error 124 ms 262144 KB Execution killed with signal 9
20 Halted 0 ms 0 KB -