Description
给你一棵\(n\)个点的树，每个点初始的时候有一个为\(1\)或\(0\)的权值，现在要支持两种操作：
\(op(1,x)\)：令\(x\)点的权值反转
\(op(2,x,d)\)：求距离\(x\)点\(\leq d\)的点中，权值为\(1\)的点组成的连通块个数（注意\(x\)点本身不算在内，也就是询问\(x\)的时候要假装\(x\)是\(0\)）
数据范围：\(1\leq n,m\leq 10^5\)
Solution
智力康复qwq码+调试搞了差不多一万年也是服了qwq
操作看过去浓浓的动态点分气息，然后连通块计数直接转成范围内权值为\(1\)的点的数量\(-\)满足两个端点的权值都是\(1\)的边数即可
所以每个分治中心上我们要维护的东西就是：权值为\(1\)的点的数量，两个端点权值都是\(1\)的边的数量
实现上的话就是树状数组搞一搞就好了
然后关于修改操作：注意到一个点修改了之后，它连出去的边都会被影响到，然而如果修改的复杂度跟点的度数挂钩随便一个菊花图就凉了，所以考虑换一种方式统计
我们把边的贡献挂在原树的父亲那里，然后对于每个点维护一下原树儿子中有多少个权值为\(1\)的即可
查询的时候注意\(d\)要\(-1\)，然后还有各种奇奇怪怪的边界的细节== 然后我个蒟蒻就写得极其丑陋了qwq
mark：连通块还是直接点数-边数计算比较好。。把贡献挂在“最上面那个点”上。。很明显有很多不优秀的地方。。
Code
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1e5+10,TOP=20,BIT=N*17*2;
struct xxx{
int y,nxt;
}a[N*2];
char s[N];
int h[N],st[N],cnt[N];
int n,m,tot,q;
namespace Bit{/*{{{*/
int c[BIT][2],st[N][2],mx[N][2];
int tot=0;
//start from 0, +1
void modify(int which,int x,int delta,int op,int tp){//tp=0: - tp=1: +
++x;
for (;x<=mx[which][op];x+=x&-x)
c[st[which][op]+x][tp]+=delta;
}
int query(int which,int op,int x,int tp){
++x;
int ret=0;
x=min(x,mx[which][op]);
for (;x;x-=x&-x) ret+=c[st[which][op]+x][tp];
return ret;
}
}/*}}}*/
void add(int x,int y){a[++tot].y=y; a[tot].nxt=h[x]; h[x]=tot;}
namespace OriT{/*{{{*/
int lis[N],dfn[N];
int dep[N],top[N],pre[N],son[N],sz[N];
int dfn_t;
void predfs(int fa,int x,int d){
int u;
dep[x]=d; ::cnt[x]=0; pre[x]=fa;
son[x]=0; sz[x]=1;
for (int i=h[x];i!=-1;i=a[i].nxt){
u=a[i].y;
if (u==fa) continue;
predfs(x,u,d+1);
::cnt[x]+=st[u];
sz[x]+=sz[u];
if (sz[u]>sz[son[x]]) son[x]=u;
}
}
void dfs1(int fa,int x){
lis[++dfn_t]=x; dfn[x]=dfn_t;
if (son[x]){
top[son[x]]=top[x];
dfs1(x,son[x]);
}
int u;
for (int i=h[x];i!=-1;i=a[i].nxt){
u=a[i].y;
if (u==fa||u==son[x]) continue;
top[u]=u;
dfs1(x,u);
}
}
void prework(){
predfs(0,1,1);
top[1]=1; dfn_t=0;
dfs1(0,1);
}
int get_lca(int x,int y){
while (top[x]!=top[y]){
if (dep[top[x]]<dep[top[y]]) swap(x,y);
x=pre[top[x]];
}
return dep[x]<dep[y]?x:y;
}
int get_dis(int x,int y){
int lca=get_lca(x,y);
return dep[x]+dep[y]-2*dep[lca];
}
int jump(int x,int d){
int aim=dep[x]-d;
if (!d) return x;
while (dep[top[x]]>aim) x=pre[top[x]];
return lis[dfn[x]-(dep[x]-aim)];
}
}/*}}}*/
namespace T{/*{{{*/
int pre[N],sz[N],mx[N];
int df_t[N];
int vis[N];
int cnt0[N],cnt1[N];//0=- 1=+
int rec[TOP+1][N][2];
int rt,rt_mx,mxdep;
void get_sz(int fa,int x){
int u;
sz[x]=1; mx[x]=0;
for (int i=h[x];i!=-1;i=a[i].nxt){
u=a[i].y;
if (u==fa||vis[u]) continue;
get_sz(x,u);
sz[x]+=sz[u];
mx[x]=max(mx[x],sz[u]);
}
}
void get_rt(int Rt,int fa,int x){
int u;
mx[x]=max(mx[x],sz[Rt]-sz[x]);
if (mx[x]<rt_mx)
rt=x,rt_mx=mx[x];
for (int i=h[x];i!=-1;i=a[i].nxt){
u=a[i].y;
if (u==fa||vis[u]) continue;
get_rt(Rt,x,u);
}
}
void dfs(int rt_t,int fa,int x,int d,int op){
int u;
mxdep=max(mxdep,d);
cnt0[d]+=::st[x]?::cnt[x]:0;
cnt1[d]+=::st[x];
rec[rt_t][x][op]=d;
for (int i=h[x];i!=-1;i=a[i].nxt){
u=a[i].y;
if (u==fa||vis[u]) continue;
dfs(rt_t,x,u,d+1,op);
}
}
void get_lis(int x,int rt,int which_t,int op){
mxdep=0;
Bit::st[rt][op]=Bit::tot;
if (op==0)
dfs(which_t,0,rt,0,op);
else
dfs(which_t,0,x,0,op);
Bit::mx[rt][op]=mxdep+1;
Bit::tot+=Bit::mx[rt][op];
for (int i=0;i<=mxdep;++i){
Bit::modify(rt,i,cnt0[i],op,0);
Bit::modify(rt,i,cnt1[i],op,1);
cnt0[i]=0; cnt1[i]=0;
}
}
void solve(int fa,int x){
int u,Rt;
rt=0,rt_mx=n;
get_sz(0,x);
get_rt(x,0,x);
Rt=rt;
df_t[Rt]=df_t[fa]+1;
pre[Rt]=fa;
get_lis(x,Rt,df_t[Rt],0);
get_lis(x,Rt,df_t[Rt],1);
vis[Rt]=1;
for (int i=h[Rt];i!=-1;i=a[i].nxt){
u=a[i].y;
if (vis[u]) continue;
solve(Rt,u);
}
}
int query(int x,int aim,int d,int tp){//tp=0: - tp=1: +
int dis=d-OriT::get_dis(x,aim),pos;
int ret=dis>=0?Bit::query(x,0,dis,tp):0;
if (pre[x]){
dis=d-OriT::get_dis(pre[x],aim)-1;
if (dis>=0){
ret-=Bit::query(x,1,dis,tp);
}
ret+=query(pre[x],aim,d,tp);
}
return ret;
}
void modify(int x,int aim,int delta,int tp){//tp=0: - tp=1:+
if (!delta) return;
Bit::modify(x,rec[df_t[x]][aim][0],delta,0,tp);
if (pre[x]){
Bit::modify(x,rec[df_t[x]][aim][1],delta,1,tp);
modify(pre[x],aim,delta,tp);
}
}
}/*}}}*/
void modify(int x){
int delta=st[x]?-1:1;
int fa=OriT::pre[x];
if (fa&&st[fa])
T::modify(fa,fa,delta,0);
if (fa) cnt[fa]+=delta;
T::modify(x,x,cnt[x]*delta,0);
T::modify(x,x,delta,1);
st[x]+=delta;
}
int query(int x,int d){
int tmp1,tmp2,fa=OriT::pre[x];
tmp1=T::query(x,x,d-1,0);
tmp2=T::query(x,x,d,1);
if (st[x]){
--tmp2;
tmp1-=cnt[x]+st[fa];
}
if (OriT::dep[x]>d){
x=OriT::jump(x,d-1);
fa=OriT::pre[x];
tmp1+=st[x]&st[fa];
}
return tmp2-tmp1;
}
void prework(){
OriT::prework();
T::solve(0,1);
}
int main(){
#ifndef ONLINE_JUDGE
freopen("a.in","r",stdin);
#endif
int x,y,op,d;
scanf("%d%d",&n,&m);
memset(h,-1,sizeof(h));
tot=0;
for (int i=1;i<n;++i){
scanf("%d%d",&x,&y);
add(x,y); add(y,x);
}
scanf("%s",s+1);
for (int i=1;i<=n;++i) st[i]=s[i]=='1';
prework();
for (int i=1;i<=m;++i){
scanf("%d",&op);
if (op==1){
scanf("%d",&x);
modify(x);
}
else{
scanf("%d%d",&x,&d);
printf("%d\n",query(x,d));
}
}
}
/*
6 3
1 2
1 3
1 4
2 5
3 6
111000
2 1 2
2 4 2
1 1
2 4 2
*/