oj.uz

Submission #894121

# Submission time Handle Problem Language Result Execution time Memory
894121 2023-12-28T01:28:00 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.reserve((int)v.size() * 2);
        for (int i = 0; i < 2 * v.size(); i++) {
            vec.push_back({});
        }
        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';
    }
}

Compilation message

sortbooks.cpp: In constructor 'MergeSortTree::MergeSortTree(std::vector<int>)':
sortbooks.cpp:55:27: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   55 |         for (int i = 0; i < 2 * v.size(); i++) {
      |                         ~~^~~~~~~~~~~~~~

Subtask #1
8.0 / 8.0

# Verdict Execution time Memory Grader output
1 Correct 0 ms 348 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 3 ms 604 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 600 KB Output is correct
6 Correct 8 ms 912 KB Output is correct
7 Correct 8 ms 860 KB Output is correct
8 Correct 6 ms 860 KB Output is correct
9 Correct 5 ms 604 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 348 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 3 ms 604 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 600 KB Output is correct
6 Correct 8 ms 912 KB Output is correct
7 Correct 8 ms 860 KB Output is correct
8 Correct 6 ms 860 KB Output is correct
9 Correct 5 ms 604 KB Output is correct
10 Correct 5 ms 604 KB Output is correct
11 Correct 104 ms 2152 KB Output is correct
12 Correct 1614 ms 7148 KB Output is correct
13 Correct 1609 ms 7164 KB Output is correct
14 Correct 1630 ms 7540 KB Output is correct
15 Correct 1556 ms 7284 KB Output is correct
16 Correct 1267 ms 7256 KB Output is correct
17 Correct 1113 ms 6736 KB Output is correct
18 Correct 1088 ms 4140 KB Output is correct

Subtask #3
0 / 13.0

# Verdict Execution time Memory Grader output
1 Runtime error 178 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 3057 ms 102068 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 348 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 3 ms 604 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 600 KB Output is correct
6 Correct 8 ms 912 KB Output is correct
7 Correct 8 ms 860 KB Output is correct
8 Correct 6 ms 860 KB Output is correct
9 Correct 5 ms 604 KB Output is correct
10 Correct 5 ms 604 KB Output is correct
11 Correct 104 ms 2152 KB Output is correct
12 Correct 1614 ms 7148 KB Output is correct
13 Correct 1609 ms 7164 KB Output is correct
14 Correct 1630 ms 7540 KB Output is correct
15 Correct 1556 ms 7284 KB Output is correct
16 Correct 1267 ms 7256 KB Output is correct
17 Correct 1113 ms 6736 KB Output is correct
18 Correct 1088 ms 4140 KB Output is correct
19 Runtime error 404 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 348 KB Output is correct
2 Correct 0 ms 348 KB Output is correct
3 Correct 3 ms 604 KB Output is correct
4 Correct 1 ms 348 KB Output is correct
5 Correct 2 ms 600 KB Output is correct
6 Correct 8 ms 912 KB Output is correct
7 Correct 8 ms 860 KB Output is correct
8 Correct 6 ms 860 KB Output is correct
9 Correct 5 ms 604 KB Output is correct
10 Correct 5 ms 604 KB Output is correct
11 Correct 104 ms 2152 KB Output is correct
12 Correct 1614 ms 7148 KB Output is correct
13 Correct 1609 ms 7164 KB Output is correct
14 Correct 1630 ms 7540 KB Output is correct
15 Correct 1556 ms 7284 KB Output is correct
16 Correct 1267 ms 7256 KB Output is correct
17 Correct 1113 ms 6736 KB Output is correct
18 Correct 1088 ms 4140 KB Output is correct
19 Runtime error 178 ms 262144 KB Execution killed with signal 9
20 Halted 0 ms 0 KB -