点分治模板

点分治一般用来处理树上路径问题，其实思想并不难理解，树型dp做多应该或多或少接触过：我们问树上某种路径的条数，那我们可以确定一个根节点，然后把所有路径分为经过这个根节点的，和不经过的。

点分治的关键是：经过的根节点的我们可以树形dp求一下，一般就是dp求一下到根节点的距离为x的点数，然后处理一下。不经过根节点的路径，他肯定会经过某个儿子，也就是会在以某个儿子为根时，转化成经过根节点，然后就可以按上述方法处理。

所以我们可以处理完一个根节点的情况后，对各个子树再找一个点为根节点，继续处理。接下来关键来了，子树的根节点怎么选择？如果随便选，可能会让所有点都作为一次根节点，每个根节点要dp，总体复杂度$O(n^2)$，显然不行。我们想让递归层数尽量少的话，应该让每次递归后，子树大小都尽可能小。那么应该选重心作为子树的根，这样每个子树的大小都不会超过原树的一半，也就是子树大小会以折半的方式减小，这类似二分的思想，最多递归$O(logn)$层，每层我们要进行$O(n)$的dp，还可能进行一些复杂度为$f(n)$的答案统计，总复杂度$O((n+f(n))logn)$

来看例题1

问树上距离恰好为$k$的点对是否存在？可以转化为问长度为k的路径是否存在，树上路径问题，考虑点分治。每一层树形dp维护到根节点距离为$x$的点是否存在，可以把所有距离都放到一个$set$里。然后我们要判断路径是否存在，这个路径一定是由两条以根为端点的链拼起来的，并且属于根的不同儿子，那么我们考虑$i$子树时，对于一个子树中到根距离为$d$的店，只要看$1,2,...,i-1$子树里是否存在距离为$k-d$的点即可，这可以直接去$set$里查，考虑完一个子树，再把这个子树的所有$d$加入$set$

剩下的一些细节是：

• 找重心是个板子题，根据重心的定义：以他为根，所有子树的大小的最大值最小的那个点是重心，所以我们$dfs$同时维护子树大小，然后每到一个点就计算它的所有子树的大小的最大值，这里需要注意的是往父亲方向走也是一颗子树
• 找重心和树形dp的时候只能在当前子树，这可以通过把每次选中的根节点标记为已访问，然后不走已访问的点来实现
• 最开始找重心，需要把重心初始值设为0，然后把子树大小最大值设为n
• 查距离为$k-d$的点是否存在，也可以开个数组标记每个距离的点是否存在，但是每次统计完一个根需要清空，而且距离可能很大，可能re，所以还是set简单，只是多一个$log$

void solve(){
	int n,m;
	cin>>n>>m;
	vector<vvi> g(n+1);
	rep(i,1,n-1){
		int u,v,w;
		cin>>u>>v>>w;
		g[u].push_back({v,w});
		g[v].push_back({u,w});
	}
	vi vis(n+1),ans(m+1),ask(m+1),mx(n+1);
	vi sz(n+1);
	rep(i,1,m){
		cin>>ask[i];
	}
	int rt=0,sum=n;
	mx[rt]=n;
	
	auto &&get_root=[&](auto &&get_root,int u,int fa)->void{
		sz[u]=1;
		mx[u]=0;
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(v==fa||vis[v])continue;
			get_root(get_root,v,u);
			sz[u]+=sz[v];
			mx[u]=max(mx[u],sz[v]);
		}
		mx[u]=max(mx[u],sum-sz[u]);
		if(mx[u]<mx[rt]){
			rt=u;
		}
	};
	auto &&get_dis=[&](auto &&get_dis,int u,int fa,vi& dis,int d)->void{
		dis.push_back(d);
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(v==fa||vis[v])continue;
			get_dis(get_dis,v,u,dis,d+w);
		}
	};
	auto cal=[&](int u)->void{
		set<int>s;
		s.insert(0);
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(vis[v])continue;
			vi dis;
			get_dis(get_dis,v,u,dis,w);
			
			for(int d:dis){
				rep(i,1,m){
					if(ask[i]>=d){
						ans[i]|=s.count(ask[i]-d);
					}
				}
			}
			for(int d:dis){
				s.insert(d);
			}
		}
	};
	auto &&work=[&](auto &&work,int u)->void{
		vis[u]=1;
		cal(u);
		
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(vis[v])continue;
			sum=sz[v];
			rt=0;
			get_root(get_root,v,u);
			work(work,rt);
		}
	};
	
	get_root(get_root,1,0);
	work(work,rt);
	rep(i,1,m){
		if(ans[i]){
			cout<<"AYE\n";
		}
		else{
			cout<<"NAY\n";
		}
	}
}

再来一个例题2

和上一个差不多，统计的是树上长度不超过$k$的路径数，在上面稍作修改即可，上面是对于一个距离$d$，找前面的子树里，是否存在距离$k-d$的点。现在是对于一个距离$d$的点，前面子树里距离不超过$k-d$的点都能和这个点组成合法路径，我们只要能统计不超过$k-d$的点数即可，这可以线段树也可以平衡树，平衡树写起来方便一点，选择平衡树

void solve(){
	int n,k;
	cin>>n;
	vector<vvi> g(n+1);
	rep(i,1,n-1){
		int u,v,w;
		cin>>u>>v>>w;
		g[u].push_back({v,w});
		g[v].push_back({u,w});
	}
	vi vis(n+1),mx(n+1);
	vi sz(n+1);
	cin>>k;
	int rt=0,sum=n,ans=0;
	mx[rt]=n;
	
	auto &&get_root=[&](auto &&get_root,int u,int fa)->void{
		sz[u]=1;
		mx[u]=0;
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(v==fa||vis[v])continue;
			get_root(get_root,v,u);
			sz[u]+=sz[v];
			mx[u]=max(mx[u],sz[v]);
		}
		mx[u]=max(mx[u],sum-sz[u]);
		if(mx[u]<mx[rt]){
			rt=u;
		}
	};
	auto &&get_dis=[&](auto &&get_dis,int u,int fa,vi& dis,int d)->void{
		dis.push_back(d);
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(v==fa||vis[v])continue;
			get_dis(get_dis,v,u,dis,d+w);
		}
	};
	auto cal=[&](int u)->void{
		RedBlackTree tr;
		tr.insert(0);
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(vis[v])continue;
			vi dis;
			get_dis(get_dis,v,u,dis,w);
			
			for(int d:dis){
				ans+=tr.countLessEqual(k-d);
			}
			for(int d:dis){
				tr.insert(d);
			}
		}
	};
	auto &&work=[&](auto &&work,int u)->void{
		vis[u]=1;
		cal(u);
		
		for(auto &t:g[u]){
			int v=t[0],w=t[1];
			if(vis[v])continue;
			sum=sz[v];
			rt=0;
			get_root(get_root,v,u);
			work(work,rt);
		}
	};
	
	get_root(get_root,1,0);
	work(work,rt);
	cout<<ans;
}