Codeforces 966 E May Holidays

最新推荐文章于 2024-08-17 02:20:06 发布

原创最新推荐文章于 2024-08-17 02:20:06 发布 · 460 阅读

0 ·

CC 4.0 BY-SA版权

分块同时被 3 个专栏收录

16 篇文章

订阅专栏

9 篇文章

订阅专栏

虚树

3 篇文章

订阅专栏

本文介绍了一种使用重构法解决特定树形数据结构问题的方法。通过构建DFS序列和使用前缀和，该方法能够在O(n)的时间复杂度内解决问题。此外，还详细介绍了虚树的应用，以及如何通过排序和数据结构操作来高效地处理节点状态的变化。

传送门.

题解：

这个如果用树形数据结构维护是非常不好搞的。

用树链剖分 $*$ 线段树 $*$ 带修主席树，也许需要 $O(n ~log^4n)$ 的复杂度，还不如暴力。

重构大法好！！！

重构的话求个dfs序+前缀和就 $O(n)$ 了。

问题在于一块里的如何求？

点数少？

虚树大法好！！
对于虚树上每个点把它在实树里到虚树父亲的路径上的点全部提出来，并按某值排序。

这个用vector存好打一些。

如何按顺序改变点的状态，一直往虚树父亲跳，同时由于已经排好序了，可以O(1)求出愤怒发生改变的个数。

Code：

#include<vector>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define abs(a) ((a) > 0 ? (a) : - (a))
#define fo(i, x, y) for(int i = x; i <= y; i ++)
#define fd(i, x, y) for(int i = x; i >= y; i --)
using namespace std;

const int N = 2e5 + 5, M = 500;

int n, m, x, y, a[N], p[N], q[N];

struct edge {
    int final[N], next[N], to[N], tot;
    void link(int x, int y) {
        next[++ tot] = final[x], to[tot] = y, final[x] = tot;
    }
} e;

int fa[17][N], dfn[N], td, dep[N];

void dg(int x) {
    p[x] = ++ td;
    for(int i = e.final[x]; i; i = e.next[i]) {
        int y = e.to[i];
        dep[y] = dep[x] + 1;
        dg(y);
    }
    q[x] = td;
}

int lca(int x, int y) {
    if(dep[x] < dep[y]) swap(x, y);
    fd(i, 16, 0) if(dep[fa[i][x]] >= dep[y]) x = fa[i][x];
    if(x == y) return x;
    fd(i, 16, 0) if(fa[i][x] != fa[i][y]) x = fa[i][x], y = fa[i][y];
    return fa[0][x];
}

int b[N];

int num[N];

struct Ka {
    int l, r;
} t[N];

int d[N], z[N], f[N], z0, g[N], g0;

int cmp(int x, int y) {
    return p[x] < p[y];
}

int cmp2(int x, int y) {
    return a[x] < a[y];
}

int u[N];

struct P {
    int x, y, s;
    P (int _x = 0, int _y = 0, int _s = 0) {x = _x, y = _y, s = _s;}
};

vector<P> v[N]; int v0[N];

int du[N], ans[N], lk[N], xiu[N], xi[N];
int h[N];

int main() {
    scanf("%d %d", &n, &m);
    fo(i, 2, n) {
        scanf("%d", &fa[0][i]);
        e.link(fa[0][i], i);
    }
    dep[1] = 1; dg(1);
    fo(i, 1, 16) fo(j, 1, n) fa[i][j] = fa[i - 1][fa[i - 1][j]];
    fo(i, 1, n) scanf("%d", &a[i]);
    fo(i, 1, m) {
        scanf("%d", &b[i]);
        num[i] = num[i - 1];
        if(i % M == 1) {
            num[i] ++;
            t[num[i] - 1].r = i - 1;
            t[num[i]].l = i;
        }
    }
    t[num[m]].r = m;
    fo(k, 1, num[m]) {
        d[d[0] = 1] = 1; fo(i, t[k].l, t[k].r) d[++ d[0]] = abs(b[i]);
        sort(d + 1, d + d[0] + 1, cmp);
        int d0 = d[0]; fo(i, 2, d[0]) d[++ d0] = lca(d[i - 1], d[i]);
        sort(d + 1, d + d0 + 1, cmp);
        d[0] = 0;
        fo(i, 1, d0) if(i == 1 || d[i] != d[i - 1])
            d[++ d[0]] = d[i];
        z0 = 0;
        fo(i, 1, d[0]) {
            int x = d[i];
            while(z0 > 0 && (p[x] < p[z[z0]] || p[x] > q[z[z0]]))
                f[z[z0]] = z[z0 - 1], z0 --;
            z[++ z0] = x;
        }
        while(z0 > 0) f[z[z0]] = z[z0 - 1], z0 --;

        int sum = 0;
        fo(i, 1, n) sum += (a[i] < 0) * !du[i];

        fo(i, 1, n) h[i] = lk[i] = xi[i] = xiu[i] = v0[i] = 0;
        fo(i, 1, d[0]) {
            int x = d[i]; if(x == 1) continue;

            u[0] = 0;
            int y = fa[0][x];
            while(y != f[x]) {
                if(!du[y]) u[++ u[0]] = y;
                y = fa[0][y];
            }

            sort(u + 1, u + u[0] + 1, cmp2);

            v[x].clear(); v[x].push_back(P(0, 0, 0));

            fo(i, 1, u[0]) {
                if(i == 1 || a[u[i - 1]] != a[u[i]]) {
                    v0[x] ++;
                    v[x].push_back(P(a[u[i]], 1, 0));
                } else v[x][v0[x]].y ++;
            }
            fo(i, 1, v0[x]) v[x][i].s = v[x][i - 1].s + v[x][i].y;
            while(lk[x] < v0[x] && v[x][lk[x] + 1].x < 0) lk[x] ++;
        }
        fo(i, t[k].l, t[k].r) {
            int x = abs(b[i]), y = b[i] > 0 ? 1 : -1;
            h[p[x]] -= y;
            if(y > 0) {
                if(a[x] + xi[x] < 0) sum --;
                du[x] = 1;
            } else {
                if(a[x] + xi[x] < 0) sum ++;
                du[x] = 0;
            }
            while(x > 0) {
                if(x != abs(b[i])) {
                    if(!du[x]) {
                        if(y > 0) if(a[x] + xi[x] == 0) sum ++;
                        if(y < 0) if(a[x] + xi[x] == -1) sum --;
                    }
                    xi[x] -= y;
                }
                if(x == 1) break;
                sum -= v[x][lk[x]].s;
                xiu[x] -= y;
                if(lk[x] < v0[x] && v[x][lk[x] + 1].x + xiu[x] < 0) lk[x] ++;
                if(lk[x] > 0 && v[x][lk[x]].x + xiu[x] >= 0) lk[x] --;
                sum += v[x][lk[x]].s;
                x = f[x];
            }
            ans[i] = sum;
        }
        fo(i, 1, n) h[i] += h[i - 1];
        fo(i, 1, n) a[i] += h[q[i]] - h[p[i]];

        sum = 0;
        fo(i, 1, n) sum += (a[i] < 0) * !du[i];
    }
    fo(i, 1, m) printf("%d ", ans[i]);
}