Submission #1361918

#TimeUsernameProblemLanguageResultExecution timeMemory
1361918kahoulPPP (EGOI23_ppp)C++20
12 / 100
84 ms35096 KiB
#include <bits/stdc++.h>
using namespace std;

const int maxn = 2e5 + 2;

struct SegmentTree {
    int n;
    vector<pair<int, int>> seg;
    vector<int> lzSum;

    SegmentTree (int N) {
        n = N;
        seg = vector<pair<int, int>>(4 * n + 10, {0, -1});
        lzSum = vector<int>(4 * n + 10, 0);
    }

    void build (int idx, int l, int r) {
        if (l == r) {
            seg[idx].second = n - l;
            return;
        }

        int m = (l + r) >> 1;
        build(idx * 2, l, m);
        build(idx * 2 + 1, m + 1, r);
        seg[idx] = max(seg[idx * 2], seg[idx * 2 + 1]);
    }

    void update (int idx, int l, int r, int i, int j, int x) {
        if (i != j) assert((false));
        if (j < l || r < i) return;
        if (l == r) {
            seg[idx].first += x;
            return;
        }

        int m = (l + r) >> 1;
        update(idx * 2, l, m, i, j, x);
        update(idx * 2 + 1, m + 1, r, i, j, x);
        seg[idx] = max(seg[idx * 2], seg[idx * 2 + 1]);
    }

    void print (int idx, int l, int r) {
        /* if (l == r) {
            cerr << l << " is " << seg[idx].first << '\n';
            return;
        }

        int m = (l + r) >> 1;
        print(idx * 2, l, m);
        print(idx * 2 + 1, m + 1, r); */
    }
};

vector<int> rel[4 * maxn];
vector<int> resp(maxn, 0);
SegmentTree seg(5);

vector<bool> is_parent(maxn, 0);
vector<int> holding(maxn, -1);
vector<int> person(maxn);
vector<int> in(maxn, 0);
vector<int> out(maxn, 0);
int i = 0;

void dfs1 (int u, int p) {
    in[u] = ++i;
    for (auto v : rel[u]) {
        if (v == p) continue;
        //cerr << u << " -> " << v << '\n';
        dfs1(v, u);
    }
    out[u] = i;
}

void dfs2 (int u, int p) {
    seg.update(1, 1, seg.n, person[u], person[u], p - u);
    resp[u] = seg.n - seg.seg[1].second; // refresh
    //cerr << "\nFor " << u << ":\n";
    seg.print(1, 1, seg.n);

    for (auto v : rel[u]) {
        if (v == p) continue;
        dfs2(v, u);
    }

    seg.update(1, 1, seg.n, person[u], person[u], u - p);
}

int main () {
    int n, m;
    cin >> n >> m;

    seg.build(1, 1, seg.n);
    seg.print(1, 1, seg.n);

    for (int i = 1; i <= m; i++) {
        int x, y;
        cin >> x >> y;
        x++; y++;

        person[i] = x;
        is_parent[i] = 1;
        //cerr << "Processing " << x << ' ' << y << '\n';

        if (holding[x] != -1) {
            is_parent[holding[x]] = 0;
            rel[i].push_back(holding[x]);
            //cerr << i << " -> " << holding[x] << '\n';
        }
        
        holding[x] = i;

        if (holding[y] != -1) {
            is_parent[holding[y]] = 0;
            rel[i].push_back(holding[y]);
            //cerr << i << " -> " << holding[y] << '\n';
            holding[y] = -1;
        }
    }

    for (int i = 1; i <= m; i++) {
        if (is_parent[i]) dfs1(i, i);
    }
    
    for (int i = 1; i <= m; i++) {
        if (is_parent[i]) dfs2(i, m + 1);
    }

    vector<int> ans(maxn, 0);

    for (int i = 1; i <= m; i++) {
        ans[resp[i]]++;
    }

    for (int i = 1; i <= n; i++) {
        cout << ans[i] << ' ';
    }
}
#Result Execution timeMemoryGrader output
Fetching results...
#Result Execution timeMemoryGrader output
Fetching results...
#Result Execution timeMemoryGrader output
Fetching results...
#Result Execution timeMemoryGrader output
Fetching results...
#Result Execution timeMemoryGrader output
Fetching results...
#Result Execution timeMemoryGrader output
Fetching results...
#Result Execution timeMemoryGrader output
Fetching results...