$ color{#0066ff}{ 题目描述 }$
疯狂科学家Mike培养了一颗有根树，由n个节点组成。每个节点是一个要么装满水要么为空的贮水容器. 树的节点用1~n编号，其中根节点为1.对于每个节点的容器，其子节点的容器均在这一容器下方，并且每个节点都由一根可以向下流水的管道与其子节点连接. Mike想要对这棵树做以下操作：
将节点v注满水. 这样v和其子节点都会充满水.
将节点v置空. 这样v及其祖先节点（从v到根节点的路径）都会被置空.
查询当前节点v是否充满水.
初始时，所有节点都为空. Mike已经制定好了他的操作顺序. 在对树进行实验前，他决定先模拟一下操作. 请你帮助Mike得出他操作后的结果.
(color{#0066ff}{输入格式})
第一行为一个整数n（1<=n<=500000），为树的节点数；
下面的n-1行为两个空格隔开的整数ai，bi（1<=ai, bi<=n），为树的边；
下一行为一个整数q（1<=q<=500000），为操作数；接下来q行，两个空格隔开的整数ci（1<=ci<=3），vi（1<=vi<=n），其中ci为操作类型（已给出），vi为被操作的节点.
这意味着给出的图为一棵树.
(color{#0066ff}{输出格式})
对于每一次操作3，如果节点v充满水，单独输出一行1，如果节点v为空，单独输出一行0. 按照操作输入的顺序输出.
(color{#0066ff}{输入样例})
5
1 2
5 1
2 3
4 2
12
1 1
2 3
3 1
3 2
3 3
3 4
1 2
2 4
3 1
3 3
3 4
3 5
(color{#0066ff}{输出样例})
0
0
0
1
0
1
0
1
(color{#0066ff}{数据范围与提示})
none
(color{#0066ff}{题解})
一个是树链操作，一个是子树操作，直接树剖，线段树甚至不用upd，因为不用维护任何东西。。
#include<bits/stdc++.h>
#define LL long long
LL in() {
char ch; LL x = 0, f = 1;
while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
return x * f;
}
const int maxn = 5e5 + 10;
struct Tree {
protected:
struct node {
node *ch[2];
int l, r, val, tag;
node(int l = 0, int r = 0, int val = 0, int tag = -1): l(l), r(r), val(val), tag(tag) {}
void trn(int v) { tag = val = v; }
void dwn() {
if(!(~tag)) return;
ch[0]->trn(tag), ch[1]->trn(tag);
tag = -1;
}
int mid() { return (l + r) >> 1; }
}*root;
void build(node *&o, int l, int r) {
o = new node(l, r, 0, -1);
if(l == r) return;
int mid = (l + r) >> 1;
build(o->ch[0], l, mid);
build(o->ch[1], mid + 1, r);
}
void lazy(node *o, int l, int r, int val) {
if(l <= o->l && o->r <= r) return o->trn(val);
o->dwn();
if(l <= o->mid()) lazy(o->ch[0], l, r, val);
if(r > o->mid()) lazy(o->ch[1], l, r, val);
}
int query(node *o, int pos) {
if(o->l == o->r) return o->val;
o->dwn();
if(pos <= o->mid()) return query(o->ch[0], pos);
else return query(o->ch[1], pos);
}
public:
void lazy(int l, int r, int val) { lazy(root, l, r, val); }
int query(int pos) { return query(root, pos); }
void build(int l, int r) { build(root, l, r); }
}s;
struct node {
int to;
node *nxt;
node(int to = 0, node *nxt = NULL): to(to), nxt(nxt) {}
};
node *head[maxn];
int dep[maxn], siz[maxn], top[maxn], fa[maxn];
int dfn[maxn], nfd[maxn], son[maxn], cnt;
void add(int from, int to) {
head[from] = new node(to, head[from]);
}
void dfs1(int x, int f) {
dep[x] = dep[fa[x] = f] + (siz[x] = 1);
for(node *i = head[x]; i; i = i->nxt) {
if(i->to == f) continue;
dfs1(i->to, x);
siz[x] += siz[i->to];
if(!son[x] || siz[i->to] > siz[son[x]]) son[x] = i->to;
}
}
void dfs2(int x, int t) {
top[nfd[dfn[x] = ++cnt] = x] = t;
if(son[x]) dfs2(son[x], t);
for(node *i = head[x]; i; i = i->nxt)
if(!dfn[i->to])
dfs2(i->to, i->to);
}
void up(int x) {
for(; top[x]; x = fa[top[x]]) s.lazy(dfn[top[x]], dfn[x], 0);
}
int main() {
int n = in();
int x, y;
for(int i = 1; i < n; i++) x = in(), y = in(), add(x, y), add(y, x);
dfs1(1, 0), dfs2(1, 1), s.build(1, n);
for(int T = in(); T --> 0;) {
x = in(), y = in();
if(x == 1) s.lazy(dfn[y], dfn[y] + siz[y] - 1, 1);
if(x == 2) up(y);
if(x == 3) printf("%d
", s.query(dfn[y]));
}
return 0;
}