Submission #1136776

#	Time	Username	Problem	Language	Result	Execution time	Memory
1136776		Shadow1	Inspections (NOI23_inspections)	C++20	0 / 100	0 ms	324 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;
    }
    set<pair<pii, pii>> s, temp; // s holds distinct disjoint ranges
    int base = 0;
    s.insert({{l[1], r[1]}, {1, 0}});
    for(int i=2; i<=m; ++i) {
        pii u = {l[i], INF};
        pair<pii,pii> k = make_pair(u, make_pair(INF, 0));
        auto left = s.upper_bound(k); 
        auto it = s.upper_bound(k);
        k = {{r[i], INF}, {INF, 0}};
        auto right = s.upper_bound(k);
        int safe = 0;
        // if(i == 3) {
        //      for(auto &S : s) {
        //         show((S).fir.fir);
        //         show((S).fir.sec);
        //     }
        // }
        if(left != s.end()) {
            for(it++; it != right && it != s.end(); ++it) {
                temp.insert(*it);
                int ri = (*it).fir.sec;
                int li = (*it).fir.fir;
                safe = ri - l[i] + ps[i-1] - ps[(*it).sec.fir] + (*it).sec.sec;
                base += ri - li + 1;
                pii k = {safe, INF};
                auto it2 = upper_bound(all(qry), k);
                if(it2 != qry.end()) continue;
                int x = it2 - qry.begin();
                ans[qry[x].sec] -= (*left).fir.sec - (*left).fir.fir + 1;
            }
        }
        bool have_l = false, have_r = false;
        if(left != s.begin()) {
            --left;
            have_l = true;
            safe = (*left).fir.sec - l[i] + ps[i-1] - ps[(*left).sec.fir] + (*left).sec.sec;
            base += min(r[i], (*left).fir.sec) - l[i] + 1;
            pii k = {safe, INF};
            auto it2 = upper_bound(all(qry), k);
            if(it2 != qry.end()) {
                int x = it2 - qry.begin();
                ans[qry[x].sec] -= min(r[i], (*left).fir.sec) - l[i] + 1; 
            }
        }
        // if(i == 2) show(base);
            --right;
        if(*right != *left) {
            have_r = true;
            safe = (*right).fir.sec - l[i] + ps[i-1] - ps[(*right).sec.fir] + (*right).sec.sec;
            base += r[i] - max(l[i], (*right).fir.fir) + 1;
            pii kk = {safe, INF};
            auto it2 = upper_bound(all(qry), kk);
            if(it2 != qry.end()) {
                int x = it2 - qry.begin();
                ans[qry[x].sec] -= r[i] - max(l[i], (*right).fir.fir) + 1;
            }
        }
        if(have_l) {
            auto g = *left;
            g.sec.sec += (g.fir.sec) - l[i] + 1;
            if(g.fir.fir < l[i]) {
                g.fir.sec = l[i] - 1;   
                s.insert(g);
            }
            g = *left;
            g.sec.sec += (g.fir.sec) - l[i] + 1;
            if(g.fir.sec > r[i]) {
                g.fir.fir = r[i] + 1;
                s.insert(g);
            }
            s.erase(left);
        }
        if(have_r) {
            auto g = *right;
            g.sec.sec += r[i] - (g.fir.fir) + 1;
            if(g.fir.sec > l[i]) {
                g.fir.fir = l[i] + 1;
                s.insert(g);
            }
            g = *left;
            g.sec.sec += r[i] - (g.fir.fir) + 1;
            if(g.fir.fir < l[i]) {
                g.fir.sec = l[i] - 1;
                s.insert(g);
            }
            s.insert(g);
            s.erase(right);
        }
        s.insert({{l[i], r[i]}, {i, 0}});
        // for(auto &S : s) {
        //         show((S).fir.fir);
        //         show((S).fir.sec);
        //     }
        for(auto &stuff : temp)
            s.erase(stuff);
        temp.clear();
        // show(base);
    }
    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: 0 / 11
• Subtask 2: 0 / 18
• Subtask 3: 0 / 22
• Subtask 4: 0 / 26
• Subtask 5: 0 / 23