Submission #1136884

#	Time	Username	Problem	Language	Result	Execution time	Memory
1136884		Shadow1	Inspections (NOI23_inspections)	C++20	33 / 100	202 ms	19440 KiB

Main

// Programmer: Shadow1

#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
using namespace std;

using ll = long long;
using ld = long double;
using ull = unsigned long long;
using str = string; // yay python!

#define i64 int64_t
#define show(x) cerr << (#x) << " = " << (x) << '\n';
#define output_vector(v) for(auto &x : v){cout << x << ' ';}cout << '\n';
#define output_pairvector(v) for(auto &x : v){cout << x.first << " " << x.second << '\n';}
#define read_vector(v) for(auto &x : v){cin >> x;}
#define vt vector
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define pii pair<int,int>
#define fir first
#define sec second
#define sz(x) ll(x.size())
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define int ll
#define discretize(x) sort(x.begin(), x.end()); x.erase(unique(x.begin(), x.end()), x.end());
const int INF = 1e15;
void solve() {
    int n, m, q;
    cin >> n >> m >> q;
    vector<int> l(m+1), r(m+1), ps(m+1);
    for(int i=1; i<=m; ++i) {
        cin >> l[i] >> r[i];
        ps[i] = ps[i-1] + r[i] - l[i] + 1;
    }
    vector<pii> qry(q);
    vector<int> ans(q);
    for(int i=0; i<q; ++i) {
        cin >> qry[i].fir;
        qry[i].sec = i;
    }
    sort(all(qry));
    set<pair<pii, pii>> s, temp; // s holds distinct disjoint ranges
    int base = 0;
    for(int i=1; i<=m; ++i) {
        // show(i);
        pii u = {l[i], INF};
        pair<pii,pii> k = make_pair(u, make_pair(INF, INF));
        auto left = s.upper_bound(k); 
        k = {{r[i], INF}, {INF, INF}};
        auto right = s.upper_bound(k);
        int safe = 0;
        if(*left != *right) {
            auto lim = right;
            lim--;
            for(auto it=left; it != lim && it != s.end(); ++it) {
                int ri = (*it).fir.sec;
                int li = (*it).fir.fir;
                // show(i);
                //     show(li);
                //     show(ri);
                assert(l[i] <= li && ri <= r[i]);
                safe = ri - l[i] + ps[i-1] - ps[(*it).sec.fir] + (*it).sec.sec;
                int d = ri - li + 1;
                // show(d);
                base += d;
                pii k = {safe, INF};
                auto it2 = upper_bound(all(qry), k);
                temp.insert(*it);
                if(it2 != qry.end()) {
                    int x = it2 - qry.begin();
                    ans[qry[x].sec] -= ri - li + 1;
                }
            }
        }
        bool have_l = false, have_r = false;
        if(left != s.begin()) {
            --left;
            if((*left).fir.sec >= l[i]) {
                have_l = true;
                safe = (*left).fir.sec - l[i] + ps[i-1] - ps[(*left).sec.fir] + (*left).sec.sec;
                int d = min(r[i], (*left).fir.sec) - max(l[i], (*left).fir.fir) + 1;
                base += d;
                pii k = {safe, INF};
                auto it2 = upper_bound(all(qry), k);
                if(it2 != qry.end()) {
                    int x = it2 - qry.begin();
                    ans[qry[x].sec] -= d;
                }
            }
        }
        // if(i == 2) show(base);
        if(right != s.begin()) {
            right--;
            if(*right != *left && (*right).fir.fir <= r[i]) {
                have_r = true;
                safe = (*right).fir.sec - l[i] + ps[i-1] - ps[(*right).sec.fir] + (*right).sec.sec;
                int d = min(r[i], (*right).fir.sec) - max(l[i], (*right).fir.fir) + 1;
                base += d;
                pii kk = {safe, INF};
                auto it2 = upper_bound(all(qry), kk);
                if(it2 != qry.end()) {
                    int x = it2 - qry.begin();
                    ans[qry[x].sec] -= d;
                }
            }
        }
        if(have_l) {
            auto g = *left;
            if(g.fir.fir <= l[i] && g.fir.sec >= r[i]) {
                // g.sec.sec += r[i] - g.fir.fir + 1;
                g.fir.fir = r[i] + 1;
                s.insert(g);
                g = *left;
                g.sec.sec += g.fir.sec - l[i] + 1;
                g.fir.sec = l[i] - 1;
                s.insert(g);
            }
            else if(g.fir.fir < l[i] && g.fir.sec >= l[i]) {
                g.sec.sec += g.fir.sec - l[i] + 1;
                g.fir.sec = l[i] - 1;
                // if(i == 3) show(g.fir.sec);
                // g.sec.fir = i;
                s.insert(g);
            }
            s.erase(left);
            
        }
        if(have_r) {
            auto g = *right;
            if(g.fir.fir <= r[i] && g.fir.sec > r[i]) {
                // g.sec.sec += r[i] - g.fir.fir + 1;
                g.fir.fir = r[i] + 1;
                // g.sec.fir = i;
                s.insert(g);
            }
            s.erase(right);
        }
        s.insert({{l[i], r[i]}, {i, 0}});
        
        for(auto &stuff : temp)
            s.erase(stuff);
        temp.clear();
        // show(base);
    }
    // for(auto &S : s) {
    //     show((S).fir.fir);
    //     show((S).fir.sec);
    // }
    ans[qry[0].sec] += base;
    for(int i=1; i<q; ++i) {
        ans[qry[i].sec] += ans[qry[i-1].sec];
    }
    output_vector(ans);
}






// CHECK YOUR OVERFLOWS!!!! 
signed main() {
    // freopen("output.txt", "w", stdout);
    // freopen("input.txt", "r", stdin);
    ios::sync_with_stdio(false);
    cin.tie(NULL); 
    int T = 1;
    // cin >> T;
    for(int tc = 1; tc <= T; ++tc) {
        // cout << "Case #" << tc << ": ";
        solve();
    }

    return 0;
}

/* CHECK :
1. COMPARATOR FUNCTION MUST RETURN FALSE WHEN ARGUMENTS ARE EQUAL!!!
2. Overflow! Typecase int64_t on operations if varaibles are int
3. Check array bounds!!!
4. Check array indexing!!!
5. Edge cases. (N==1)!!!
*/

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