P4332 [SHOI2014]三叉神经树

要求维护一棵树：

• 每个点有 $3$ 个端口，分为输入端和输出端（连向父亲）。输出端的个数 $\leq 1$。
• 如果一个点输入端权值为 $1$ 的个数 $\geq 2$，那么这个点的权值为 $1$，否则为 $0$。
• 支持动态修改叶子节点，修改后询问根节点的权值。

$1 \leq n \leq 5\times 10^5$，时限 $4\text{s}$，空限 $250\text{MB}$。

sol

可以发现，每一次修改叶子节点后，权值改变的点的集合一定是一条自上而下的链，且这条链开头不定，但结尾一定是被修改点。

然后我们还可以发现（此处记 $sum_i$ 表示 $i$ 点的三个儿子中，权值为 $1$ 的点得个数）：

• 若被修改点是从 $1$ 改成 $0$ 的，那么从被修改点开始向上，只有 $sum=2$ 的点的颜色改变（从 $1$ 变成 $0$）。
• 若被修改点是从 $0$ 改成 $1$ 的，那么从被修改点开始向上，只有 $sum=1$ 的点的颜色改变（从 $0$ 变成 $1$）。

那么，求出一个点子树内最深的 $sum \ne 1$ 或 $sum \ne 2$ 的点即为修改这个点的子树内的叶子节点的链头。

那么怎么维护？

$\mathcal O(n \log^3 n)$

考虑树链剖分，用线段树维护区间最小值和最大值，当且仅当某个区间的最小值和最大值均为 $1$ 或 $2$ 时才表示这一链的点的权值均为 $1$ 或 $2$。

至于链头，则可以通过二分或倍增来找，总时间复杂度为 $\mathcal O(n \log^3 n)$。

具体地，二分 $\mathcal O(\log n)$，跳重链 $\mathcal O(\log n)$，线段树查询 $\mathcal O(\log n)$。

$\mathcal O(n \log^2 n)$

用 LCT 可以 $\mathcal O(\log n)$ 实现查询链上最大最小值。

故总时间复杂度优化为 $\mathcal O(n \log^2 n)$。

$\mathcal O(n \log n)$

考虑更直接的方法，维护一个点的信息。

讨论一下，修改 push_up 和 push_down 函数即可。

总时间复杂度为 $\mathcal O(n \log n)$。

许多细节。

具体参考代码。

#include <bits/stdc++.h>

#define lc c[x][0]
#define rc c[x][1]

using namespace std;

inline int read()
{
    int x = 0, f = 1;
    char c = getchar();
    while (c < '0' || c > '9')
    {
        if (c == '-')
            f = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
        x = x * 10 + c - '0', c = getchar();
    return x * f;
}

const int _ = 1.5e6 + 10;

struct LCT
{
	int f[_], c[_][2], id[_][3], v[_], s[_], st[_];
	int lz[_];
	inline bool isroot(int x)
	{
		return c[f[x]][0] == x || c[f[x]][1] == x;
	}
	inline void push_up(int x)
	{
		id[x][1] = id[rc][1];
		id[x][2] = id[rc][2];
		if(!id[x][1])
		{
			if(s[x] != 1)
				id[x][1] = x;
			else
				id[x][1] = id[lc][1];
		}
		if(!id[x][2])
		{
			if(s[x] != 2)
				id[x][2] = x;
			else
				id[x][2] = id[lc][2];
		}
	}
	inline void push_(int t, int x)
	{
		s[t] += x, v[t] = s[t] > 1;
		swap(id[t][1], id[t][2]);
		lz[t] += x;
	}
	inline void push_down(int x)
	{
		if(lz[x])
		{
			if(lc)
				push_(lc, lz[x]);
			if(rc)
				push_(rc, lz[x]);
			lz[x] = 0;
		}
	}
	inline void rotate(int x)
	{
		int y = f[x], z = f[y], k = c[y][1] == x, w = c[x][!k];
		if(isroot(y))
			c[z][c[z][1] == y] = x;
		c[x][!k] = y, c[y][k] = w;
		if(w)
			f[w] = y;
		f[y] = x, f[x] = z;
		push_up(y);
	}
	inline void splay(int x)
	{
		int y = x, z = 0;
		st[++z] = y;
		while(isroot(y))
			st[++z] = y = f[y];
		while(z)
			push_down(st[z--]);
		while(isroot(x))
		{
			y = f[x], z = f[y];
			if(isroot(y))
				rotate((c[y][0] == x) ^ (c[z][0] == y) ? x : y);
			rotate(x);
		}
		push_up(x);
	}
	inline void access(int x)
	{
		for(int y = 0; x; x = f[y = x])
			splay(x), rc = y, push_up(x);
	}
} tr;

int n, m;

#define pr printf

int tot, head[_], to[_ << 1], nxt[_ << 1];

void add(int u, int v)
{
	to[++tot] = v, nxt[tot] = head[u], head[u] = tot;
}

void dfs(int x, int f)
{
	tr.s[x] = 0;
	for(int i = head[x], v; i; i = nxt[i])
	{
		v = to[i];
		if(v == f) continue;
		dfs(v, x);
		tr.s[x] += tr.v[v];
	}
	if(x <= n)
		tr.v[x] = tr.s[x] > 1;
}

signed main()
{
	n = read();
	int x;
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= 3; ++j)
		{
			x = read();
			tr.f[x] = i;
			add(x, i), add(i, x);
		}
	for(int i = n + 1; i <= n * 3 + 1; ++i)
		tr.v[i] = read();
	dfs(1, 0);
	m = read();
	int lst, w, addtag, ans = tr.v[1];
	while(m--)
	{
		lst = read(), x = tr.f[lst];
		addtag = tr.v[lst] ? -1 : 1;
		tr.access(x), tr.splay(x);
		w = tr.id[x][tr.v[lst] ? 2 : 1];
		if(w)
		{
			tr.splay(w);
			tr.push_(tr.c[w][1], addtag);
			tr.push_up(w);
			tr.s[w] += addtag, tr.v[w] = tr.s[w] > 1;
			tr.push_up(w);
		}
		else
		{
			ans ^= 1;
			tr.push_(x, addtag);
			tr.push_up(x);
		}
		tr.v[lst] ^= 1;
		pr("%d\n", ans);
	}
	return 0;
}