Submission #1200524

#	Time	Username	Problem	Language	Result	Execution time	Memory
1200524		ofoz	Inspections (NOI23_inspections)	C++20	0 / 100	0 ms	328 KiB

Main

#include <bits/stdc++.h>
#define int long long
using namespace std;
#define pi pair<int, int>
#define ppi pair<pair<int, int>, int>
#define vi vector<int>

void solve() {
    int n, m, q;
    cin >> n >> m >> q;
    int s = 0;
    vector<ppi> pairs;
    for (int i = 0; i < m; i++) {
        int l, r;
        cin >> l >> r;
        pairs.push_back({{l, r}, s});
        s += (r-l+1);
    }
    vector<pi> queries(q);
    int x;
    for (int i = 0; i < q; i++) {
        cin >> x;
        queries[i] = {x, i};
    }
    
    sort(pairs.rbegin(), pairs.rend());
    map<int, int> mx;
    map<pi, int> last; // the last time a given pair of indices was joined together
    set<pi> cur;
    multiset<pi> end;

    int start = 0;
    int left = 0;
    for (int i = 1; i <= n; i++) {
        while (!pairs.empty() && pairs.back().first.first <= i) {
            cur.insert({pairs.back().second - i + 1, i});
            end.insert({pairs.back().first.second, pairs.back().second - i + 1});
            set<pi>::iterator it = cur.lower_bound({pairs.back().second - i + 1, i});
            pairs.pop_back();
            
            set<pi>::iterator prv, nxt;
            if (it != cur.begin() && it != prev(cur.end(), 1)) {
                nxt = next(it, 1);
                prv = prev(it, 1);
                int diff = nxt->first - prv->first;
                int l = last[{prv->second, nxt->second}];
                assert(l != 0);

                mx[diff] += (i - l);
                start += (i - l);
            }

            if (it != cur.begin()) {
                prv = prev(it, 1);
                last[{prv->second, it->second}] = i;
            }
            if (it != prev(cur.end(), 1)) {
                nxt = next(it, 1);
                last[{it->second, nxt->second}] = i;
            }
        }
        
        while (!end.empty() && end.begin()->first < i) {
            set<pi>::iterator it = cur.upper_bound({end.begin()->second, -1});
            set<pi>::iterator prv, nxt;

            if (it != cur.begin() && it != prev(cur.end(), 1)) {
                nxt = next(it, 1);
                prv = prev(it, 1);
                last[{prv->second, nxt->second}] = i;
            }

            if (it != cur.begin()) {
                prv = prev(it, 1);
                int diff = it->first - prv->first;
                int l = last[{prv->second, it->second}];
                assert(l != 0);
                mx[diff] += (i - l);
                start += (i - l);
            }
            if (it != prev(cur.end(), 1)) {
                nxt = next(it, 1);
                int diff = nxt->first - it->first;
                int l = last[{it->second, nxt->second}];
                assert(l != 0);
                mx[diff] += (i - l);
                start += (i - l);
            }

            cur.erase(it);
            end.erase(end.begin());
        }
        
    }



    vector<int> res(q);
    sort(queries.begin(), queries.end());
    int j = 0;
    int c = start;
    for (pi p : mx) {
        while (j < q && queries[j].first < p.first) {
            res[queries[j].second] = c;
            j++;
            continue;
        }
        c -= p.second;
        if (j >= q) break;
        if (p.first > queries[j].first) continue;
        res[queries[j].second] = c;
    }
    for (int x : res) cout << x << ' ';
}

/*
given a certain amount of integers, calculate the count of their differences
*/
signed main() {
    solve();
    return 0;
}

• Subtask 1: 0 / 11
• Subtask 2: 0 / 18
• Subtask 3: 0 / 22
• Subtask 4: 0 / 26
• Subtask 5: 0 / 23