Submission #561741

#	Time	Username	Problem	Language	Result	Execution time	Memory
561741		timreizin	Examination (JOI19_examination)	C++17	100 / 100	2193 ms	201844 KiB

examination

#include <iostream>
#include <vector>
#include <algorithm>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

struct score
{
    int s, t, sum;

    score(int s = 0, int t = 0, int sum = 0) : s(s), t(t), sum(sum)
    {

    }
};

struct query
{
    int i;
    int a, b, c;

    query(int i = 0, int a = 0, int b = 0, int c = 0) : i(i), a(a), b(b), c(c)
    {

    }
};

using ordered_set = tree<pair<int, int>, null_type, greater<>, rb_tree_tag, tree_order_statistics_node_update>;

struct segtree
{
    int n;
    vector<ordered_set> tree;

    segtree(int n = 0) : n(n)
    {
        tree.resize(4 * n + 5);
    }
//count >=b in [a, b]
    int get(int a, int b, int val, int l, int r, int v)
    {
        if (a > r || b < l) return 0;
        if (a == l && b == r) return tree[v].order_of_key({val, -1});
        int m = (l + r) >> 1;
        return get(a, min(b, m), val, l, m, v << 1) + get(max(a, m + 1), b, val, m + 1, r, v << 1 | 1);
    }
    //>= sum, >= b
    int get(int sum, int b)
    {
        return get(sum, n - 1, b, 0, n - 1, 1);
    }

    void update(int p, int val, int l, int r, int v)
    {
        if (l > r) return;
        tree[v].insert({val, tree[v].size()});
        if (l == r) return;
        int m = (l + r) >> 1;
        if (p <= m) update(p, val, l, m, v << 1);
        else update(p, val, m + 1, r, v << 1 | 1);
    }

    void update(int sum, int b)
    {
        update(sum, b, 0, n - 1, 1);
    }
};

int main()
{
    cin.tie(0)->sync_with_stdio(0);
    int n, q;
    cin >> n >> q;
    vector<score> st(n);
    vector<int> compress;
    for (auto &i : st)
    {
        cin >> i.s >> i.t;
        i.sum = i.s + i.t;
        compress.push_back(i.sum);
    }
    vector<query> queries(q);
    for (int i = 0; i < q; ++i)
    {
        cin >> queries[i].a >> queries[i].b >> queries[i].c;
        queries[i].i = i;
        compress.push_back(queries[i].c);
    }
    sort(compress.begin(), compress.end());
    compress.erase(unique(compress.begin(), compress.end()), compress.end());
    for (auto &i : st) i.sum = distance(compress.begin(), lower_bound(compress.begin(), compress.end(), i.sum));
    for (auto &i : queries) i.c = distance(compress.begin(), lower_bound(compress.begin(), compress.end(), i.c));
    int mx = compress.size();
    sort(st.begin(), st.end(), [](auto a, auto b){ return a.s > b.s; });
    sort(queries.begin(), queries.end(), [](auto a, auto b){ return a.a > b.a; });
    vector<int> res(q);
    int ind = 0;
    segtree help(mx);
    for (auto i : queries)
    {
        while (ind < n && st[ind].s >= i.a)
        {
            //update
            help.update(st[ind].sum, st[ind].t);
            ++ind;
        }
        res[i.i] = help.get(i.c, i.b);
    }
    for (int i : res) cout << i << '\n';
    return 0;
}

• Subtask 1: 2 / 2
• Subtask 2: 20 / 20
• Subtask 3: 21 / 21
• Subtask 4: 57 / 57