Submission #160954

#	Time	Username	Problem	Language	Result	Execution time	Memory
160954		Minnakhmetov	New Home (APIO18_new_home)	C++14	47 / 100	5119 ms	364568 KiB

new_home

#include <bits/stdc++.h>
    
#define ll long long
#define all(aaa) aaa.begin(), aaa.end()
  
using namespace std;
 
struct E {
    int p, t, x, y;
};
 
struct U {
    int l, r;
    pair<int, int> p;
};
 
const int N = 3e5 + 5, INF = 1e9, MAX = 1e8;
int n, q, k, cc, cq;
int ans[N], loc[N], num[N];
unordered_map<int, vector<int>> mp[N];
 
vector<int> vx;
multiset<int> occ[N];
vector<pair<int, int>> t[N * 4], t2[N * 4];
vector<U> updates;
 
void upd(int l, int r, pair<int, int> p, int v, int L, int R) {
    if (l > r)
        return;
    if (L == l && R == r) {
        t[v].push_back(p);
    }
    else {
        int m = (L + R) >> 1;
        upd(l, min(m, r), p, v * 2, L, m);
        upd(max(m + 1, l), r, p, v * 2 + 1, m + 1, R);
    }
}
 
void startSeg(int x, int y) {
    mp[x][y].push_back(cq);
}
 
void endSeg(int x, int y) {
    updates.push_back({mp[x][y].back(), cq - 1, {x, y}});
    mp[x][y].pop_back();
}
 
void updBeg(int x, bool add) {
    if (add)
        startSeg(0, x);
    else
        endSeg(0, x);
}
 
void updBetween(int x, int y, bool add) {
    if (x == y)
        return;
    int m = (x + y) >> 1;
    if ((x + y) & 1)
        m++;
 
    int m1 = lower_bound(all(vx), m) - vx.begin();
    if (add)
        startSeg(m1, y);
    else
        endSeg(m1, y);  
}
 
void calcAns(int v, int L, int R) {
    if (L == R) {
        t2[v] = {{loc[L], num[L]}};
    }
    else {
        int m = (L + R) >> 1;
        calcAns(v * 2, L, m);
        calcAns(v * 2 + 1, m + 1, R);
        merge(all(t2[v * 2]), all(t2[v * 2 + 1]), back_inserter(t2[v]));
    }
 
    int i = 0, mx = -INF;
    for (auto &p : t2[v]) {
        while (i < t[v].size() && t[v][i].first <= p.first) {
            mx = max(mx, t[v][i].second);
            i++;
        }
        ans[p.second] = max(ans[p.second], mx - vx[p.first]);
    }
}
 
void solve(vector<E> evs) {
    vx.clear();
    updates.clear();
 
 
    for (int i = 0; i < N; i++) {
        occ[i].clear();
        mp[i].clear();
    }
 
    for (int i = 0; i < N * 4; i++) {
        t[i].clear();
        t2[i].clear();
    }
 
    for (E e : evs) {
        if (e.t == 2)
            vx.push_back(e.x);
    }
 
    sort(all(vx));
    vx.erase(unique(all(vx)), vx.end());
 
    cq = 0;
 
    for (E e : evs) {
        if (e.t == 0) {
            auto it = occ[e.y].upper_bound(e.x);
            if (!occ[e.y].empty()) {
                if (it != occ[e.y].begin() && it != occ[e.y].end()) {
                    updBetween(*prev(it), *it, false);
                }
                if (it == occ[e.y].begin()) {
                    updBeg(*it, false);
                }
            }
 
            it = occ[e.y].insert(e.x);
 
            if (it == occ[e.y].begin()) 
                updBeg(*it, true);
            else
                updBetween(*prev(it), *it, true);
 
            if (next(it) != occ[e.y].end())
                updBetween(*it, *next(it), true);
 
        }
        else if (e.t == 1) {
            auto it = occ[e.y].find(e.x);
 
            if (it == occ[e.y].begin()) 
                updBeg(*it, false);
            else
                updBetween(*prev(it), *it, false);
 
            if (next(it) != occ[e.y].end())
                updBetween(*it, *next(it), false);
 
            if (it != occ[e.y].begin() && next(it) != occ[e.y].end())
                updBetween(*prev(it), *next(it), true);
            if (it == occ[e.y].begin() && occ[e.y].size() > 1)
                updBeg(*next(it), true);
 
            occ[e.y].erase(it);
        }
        else {
            loc[cq] = lower_bound(all(vx), e.x) - vx.begin();
            num[cq] = e.y;
            cq++;
        }
    }
 
    sort(all(updates), [](const U &a, const U &b) {
        return a.p.first < b.p.first;
    });
 
    for (U u : updates) {
        upd(u.l, u.r, u.p, 1, 0, q - 1);
    }
 
    calcAns(1, 0, q - 1);
}
 
signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);
 
    cin >> n >> k >> q;
 
    vector<E> evs;
 
    for (int i = 0; i < n; i++) {
        int x, t, a, b;
        cin >> x >> t >> a >> b;
        t--;
        evs.push_back({a, 0, x, t});
        evs.push_back({b + 1, 1, x, t});
        vx.push_back(x);
    }
 
    for (int i = 0; i < k; i++) {
        evs.push_back({1, 0, INF, i});
        evs.push_back({MAX, 1, INF, i});
    }
 
    for (int i = 0; i < q; i++) {
        int x, y;
        cin >> x >> y;
        evs.push_back({y, 2, x, i});
    }
 
    sort(all(evs), [](const E &a, const E &b) {
        return a.p == b.p ? a.t < b.t : a.p < b.p;
    });
 
    solve(evs);
    for (E &e : evs)
        e.x = INF - e.x;
    solve(evs);
 
    for (int i = 0; i < q; i++) {
        if (ans[i] < INF / 2) {
            cout << ans[i] << "\n";
        }
        else {
            cout << "-1\n";
        }
    }
 
    return 0;
}

Compilation message (stderr)

new_home.cpp: In function 'void calcAns(int, int, int)':
new_home.cpp:83:18: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
         while (i < t[v].size() && t[v][i].first <= p.first) {
                ~~^~~~~~~~~~~~~

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