Submission #1100409

#	Time	Username	Problem	Language	Result	Execution time	Memory
1100409		vladilius	New Home (APIO18_new_home)	C++17	47 / 100	2187 ms	1048576 KiB

new_home

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define pb push_back
#define ff first
#define ss second
#define arr3 array<int, 3>
const int inf = 1e8;
const int inff = inf + 1;
 
struct IT{
    struct node{
        node *l, *r;
        multiset<int> s1, s2, s3, s4;
        int m1, m2, m3, m4;
        node(){
            l = r = 0;
            m1 = m3 = inff; m2 = m4 = 0;
        }
    };
    node *rt;
    void init(){
        rt = new node();
    }
    void recalc(node *v){
        v -> m1 = v -> m3 = inff; v -> m2 = v -> m4 = 0;
        if (v -> l){
            v -> m1 = min(v -> m1, v -> l -> m1);
            v -> m2 = max(v -> m2, v -> l -> m2);
            v -> m3 = min(v -> m3, v -> l -> m3);
            v -> m4 = max(v -> m4, v -> l -> m4);
        }
        if (v -> r){
            v -> m1 = min(v -> m1, v -> r -> m1);
            v -> m2 = max(v -> m2, v -> r -> m2);
            v -> m3 = min(v -> m3, v -> r -> m3);
            v -> m4 = max(v -> m4, v -> r -> m4);
        }
    }
    void add1(node *v, int tl, int tr, int p, int x, bool t){
        if (tl == tr){
            if (t){
                (v -> s4).insert(x);
                v -> m4 = max(v -> m4, x);
            }
            else{
                (v -> s3).insert(x);
                v -> m3 = min(v -> m3, x);
            }
            return;
        }
        int tm = (tl + tr) / 2;
        if (p <= tm){
            if (!(v -> l)) v -> l = new node();
            add1(v -> l, tl, tm, p, x, t);
        }
        else {
            if (!(v -> r)) v -> r = new node();
            add1(v -> r, tm + 1, tr, p, x, t);
        }
        recalc(v);
    }
    void add2(node *v, int tl, int tr, int p, int x, bool t){
        if (tl == tr){
            if (t){
                (v -> s2).insert(x);
                v -> m2 = max(v -> m2, x);
            }
            else{
                (v -> s1).insert(x);
                v -> m1 = min(v -> m1, x);
            }
            return;
        }
        int tm = (tl + tr) / 2;
        if (p <= tm){
            if (!(v -> l)) v -> l = new node();
            add2(v -> l, tl, tm, p, x, t);
        }
        else {
            if (!(v -> r)) v -> r = new node();
            add2(v -> r, tm + 1, tr, p, x, t);
        }
        recalc(v);
    }
    void add(int l, int r){
        if (l == 1){
            add1(rt, 1, inf, r, r + 1, 1);
            return;
        }
        if (r == inf){
            add1(rt, 1, inf, l, l - 1, 0);
            return;
        }
        int m = (l + r) / 2;
        if (l <= m) add2(rt, 1, inf, m, l - 1, 0);
        if (m < r) add2(rt, 1, inf, m + 1, r + 1, 1);
    }
    void rem1(node *v, int tl, int tr, int p, int x, bool t){
        if (tl == tr){
            if (t){
                (v -> s4).erase((v -> s4).find(x));
                v -> m4 = (v -> s4).empty() ? 0 : *prev((v -> s4).end());
            }
            else{
                (v -> s3).erase((v -> s3).find(x));
                v -> m3 = (v -> s3).empty() ? inff : *(v -> s3).begin();
            }
            return;
        }
        int tm = (tl + tr) / 2;
        if (p <= tm){
            rem1(v -> l, tl, tm, p, x, t);
        }
        else {
            rem1(v -> r, tm + 1, tr, p, x, t);
        }
        recalc(v);
    }
    void rem2(node *v, int tl, int tr, int p, int x, bool t){
        if (tl == tr){
            if (t){
                (v -> s2).erase((v -> s2).find(x));
                v -> m2 = (v -> s2).empty() ? 0 : *prev((v -> s2).end());
            }
            else{
                (v -> s1).erase((v -> s1).find(x));
                v -> m1 = (v -> s1).empty() ? inff : *(v -> s1).begin();
            }
            return;
        }
        int tm = (tl + tr) / 2;
        if (p <= tm){
            rem2(v -> l, tl, tm, p, x, t);
        }
        else {
            rem2(v -> r, tm + 1, tr, p, x, t);
        }
        recalc(v);
    }
    void rem(int l, int r){
        if (l == 1){
            rem1(rt, 1, inf, r, r + 1, 1);
            return;
        }
        if (r == inf){
            rem1(rt, 1, inf, l, l - 1, 0);
            return;
        }
        int m = (l + r) / 2;
        if (l <= m) rem2(rt, 1, inf, m, l - 1, 0);
        if (m < r) rem2(rt, 1, inf, m + 1, r + 1, 1);
    }
    int get1(node *v, int tl, int tr, int l, int r, bool t){
        if (l > tr || r < tl) return inff * !t;
        if (l <= tl && tr <= r) return (t) ? (v -> m2) : (v -> m1);
        int tm = (tl + tr) / 2, out = inff * !t;
        if (v -> l){
            if (t){
                out = max(out, get1(v -> l, tl, tm, l, r, t));
            }
            else {
                out = min(out, get1(v -> l, tl, tm, l, r, t));
            }
        }
        if (v -> r){
            if (t){
                out = max(out, get1(v -> r, tm + 1, tr, l, r, t));
            }
            else {
                out = min(out, get1(v -> r, tm + 1, tr, l, r, t));
            }
        }
        return out;
    }
    int get2(node *v, int tl, int tr, int l, int r, bool t){
        if (l > tr || r < tl) return inff * !t;
        if (l <= tl && tr <= r) return (t) ? (v -> m4) : (v -> m3);
        int tm = (tl + tr) / 2, out = inff * !t;
        if (v -> l){
            if (t){
                out = max(out, get2(v -> l, tl, tm, l, r, t));
            }
            else {
                out = min(out, get2(v -> l, tl, tm, l, r, t));
            }
        }
        if (v -> r){
            if (t){
                out = max(out, get2(v -> r, tm + 1, tr, l, r, t));
            }
            else {
                out = min(out, get2(v -> r, tm + 1, tr, l, r, t));
            }
        }
        return out;
    }
    pii get(int x){
        return {min(get1(rt, 1, inf, x, inf, 0), get2(rt, 1, inf, 1, x, 0)), max(get1(rt, 1, inf, 1, x, 1), get2(rt, 1, inf, x, inf, 1))};
    }
};
 
int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    
    int n, k, q; cin>>n>>k>>q;
    vector<int> x(n + 1), t(n + 1), a(n + 1), b(n + 1);
    for (int i = 1; i <= n; i++){
        cin>>x[i]>>t[i]>>a[i]>>b[i];
    }
    vector<int> xq(q + 1), yq(q + 1);
    for (int i = 1; i <= q; i++){
        cin>>xq[i]>>yq[i];
    }
 
    vector<arr3> mp;
    for (int i = 1; i <= n; i++){
        mp.pb({a[i], 1, i});
        if (b[i] < inf) mp.pb({b[i] + 1, 2, i});
    }
    for (int i = 1; i <= q; i++){
        mp.pb({yq[i], i + 2, xq[i]});
    }
    
    auto cmp = [&](arr3 x, arr3 y){
        if (x[0] == y[0]){
            return x[1] < y[1];
        }
        return x[0] < y[0];
    };
    
    sort(mp.begin(), mp.end(), cmp);
    
    vector<int> out(q + 1), cnt(k + 1);
    multiset<int> st[k + 1];
    int df = 0, l, r;
    IT T; T.init();
    for (auto [X, tt, i]: mp){
        if (tt == 1){
            df += !cnt[t[i]];
            cnt[t[i]]++;
            if (cnt[t[i]] == 1){
                if (1 < x[i]) T.add(1, x[i] - 1);
                if (x[i] < inf) T.add(x[i] + 1, inf);
                st[t[i]].insert(x[i]);
                continue;
            }
            
            if (st[t[i]].find(x[i]) != st[t[i]].end()){
                st[t[i]].insert(x[i]);
                continue;
            }
            
            auto it = st[t[i]].upper_bound(x[i]);
            if (it == st[t[i]].end()) r = inf;
            else r = (*it) - 1;
            if (it == st[t[i]].begin()) l = 1;
            else l = *prev(it) + 1;
            
            if (l <= r) T.rem(l, r);
            if (l < x[i]) T.add(l, x[i] - 1);
            if (x[i] < r) T.add(x[i] + 1, r);
            
            st[t[i]].insert(x[i]);
        }
        else if (tt == 2){
            cnt[t[i]]--;
            df -= !cnt[t[i]];
            
            if (st[t[i]].count(x[i]) > 1){
                st[t[i]].erase(st[t[i]].find(x[i]));
                continue;
            }
            
            auto it = st[t[i]].find(x[i]);
            
            if (it == st[t[i]].begin()) l = 1;
            else l = *prev(it) + 1;
            if (it == prev(st[t[i]].end())) r = inf;
            else r = *next(it) - 1;
            
            if (l < x[i]) T.rem(l, x[i] - 1);
            if (x[i] < r) T.rem(x[i] + 1, r);
            
            if (cnt[t[i]]) T.add(l, r);
            st[t[i]].erase(it);
        }
        else {
            int ii = tt - 2;
            if (df < k){
                out[ii] = -1;
                continue;
            }
            
            auto [l, r] = T.get(i);
            if (l != inff) out[ii] = max(out[ii], i - l);
            if (r != 0) out[ii] = max(out[ii], r - i);
        }
    }
    
    for (int i = 1; i <= q; i++){
        cout<<out[i]<<"\n";
    }
}

• Subtask 1: 5 / 5
• Subtask 2: 7 / 7
• Subtask 3: 0 / 10
• Subtask 4: 0 / 23
• Subtask 5: 35 / 35
• Subtask 6: 0 / 20