万家灯火

### Description

　　给你一棵(n)个点的树，每个点初始的时候有一个为(1)或(0)的权值，现在要支持两种操作：

(op(1,x))：令(x)点的权值反转

(op(2,x,d))：求距离(x)点(leq d)的点中，权值为(1)的点组成的连通块个数（注意(x)点本身不算在内，也就是询问(x)的时候要假装(x)是(0)）

　　数据范围：(1leq n,mleq 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
",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
*/