点分治用来解决树上距离的问题。
最经典，最模板的一道题：给定一棵树，给定一棵有n个点的树，询问树上距离为k的点对是否存在。
对于上面那个问题，我们可以O(n^2)枚举点对，然后对每个点对跑一遍LCA，复杂度是O(n^2·log(n))的，这显然不能让我们接受。那么，我们的点分治可以解决这类问题：首先，我们对每个点进行分析，对于每个点，我们有两种情况：
*1、经过这个点的路径
*2、不经过这个点，且在这个点的子树中的路径
点分治的思想就是对于每个点处理情况1，然后进行分治，分治到它的儿子节点再处理情况1，不断这样分治下去，就把情况2解决了。
也就是说，我们不断求情况1，对于情况2，它肯定会在这个点的子树中经过情况1而解决，那么我们就找到这棵子树的根，再对他求一次情况1。
那么问题来了，如果这棵树退化成链呢？从根一层一层往下分治显然是不优的，需要分治n层，这时候，就需要我们的重心：它能让哪怕是链上的分治也是log的，因为重心把树分成n/2,n/2个节点。至于正确性，我们把重心拿掉就是两棵分别独立的树，它们之间互不影响，那么正确性肯定是不影响的。
综上，我们把点分治大致思路了解了，那么接下来是细节：
我们令judge[dis]表示在rt子树v[1~k]中是否存在某个节点到rt距离为dis，也就是目前遍历的子树中是否存在到rt距离为dis，然后对于接下来的一棵子树，他到rt的距离为rem[i]，若当前询问距离为que[k]，那么我们只需要判断judge[que[k]-rem[i]]是否等于1即可。
再具体点解释这段话操作的含义，就是用子树vi中某个结点与子树v[1~i-1]中某个节点两两配对，检查是否存在长度为que[k]的路径。
像这样配对完后将这棵子树的rem(即子树vi中每个节点到rt的dis)一起保存进judge数组，继续下一个子树v[i+1]的处理，它有一个很大的好处就是所有边都只会遍历一遍，不会有重复情况，所有不用考虑去重。但是因为judge是个桶，所以如果边权太大就不能用这种方法了。
当以rt为根的树查询完后清空judge数组， 然后对其他子树进行分治
代码如下：
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<cstring>
using namespace std;
const int MaxK=20000000;
const int MaxN=20000;
const int MaxM=200;
int n,m,que[MaxM];
int last[MaxN],tot;
int mxrt[MaxN],size[MaxN],vis[MaxN],nmax,sum,rt;
int rem[MaxN],sre,numb[MaxM],q[MaxN],dis[MaxN];
bool judge[MaxK];//长度是最长的边MaxK
struct edge{
int to,next,w;
}e[MaxN*4];
inline void add_edge(int x,int y,int w){
e[++tot].to=y;e[tot].next=last[x];e[tot].w=w;last[x]=tot;
return;
}
inline int read(){
int s=0,w=1;
char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-') w=-1;ch=getchar();}
while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
return s*w;
}
inline void getrt(int x,int fa){
mxrt[x]=0;size[x]=1;
for(int i=last[x];i;i=e[i].next){
int u=e[i].to;
if(u==fa||vis[u]) continue;
getrt(u,x);size[x]+=size[u];
mxrt[x]=max(mxrt[x],size[u]);
}
mxrt[x]=max(mxrt[x],sum-size[x]);
if(mxrt[x]<nmax) nmax=mxrt[x],rt=x;
return;
}
inline void dfs(int x,int fa){
rem[++sre]=dis[x];
for(int i=last[x];i;i=e[i].next){
int u=e[i].to;
if(u==fa||vis[u]) continue;
dis[u]=dis[x]+e[i].w;
dfs(u,x);
}
return;
}
inline void calc(int x){
int ls=0;
for(int i=last[x];i;i=e[i].next){
int u=e[i].to;
if(vis[u]) continue;
dis[u]=e[i].w;//以x为根，它子树到x的距离巧妙的赋值省去清零操作
sre=0;dfs(u,x);
for(int j=1;j<=m;++j){
for(int k=1;k<=sre;++k){
if(que[j]>=rem[k]){
if(judge[que[j]-rem[k]]){
numb[j]=1;break;
}
}
}
}
for(int j=1;j<=sre;++j) q[++ls]=rem[j],judge[rem[j]]=1;
}
for(int i=1;i<=ls;++i) judge[q[i]]=0;//记得清空
return;
}
inline void solve(int x){//对于每个点开始分治
vis[x]=judge[0]=1;calc(x);
for(int i=last[x];i;i=e[i].next){
int u=e[i].to;
if(vis[u]) continue;
nmax=0x3f3f3f3f;sum=size[u];
getrt(u,x);solve(rt);
}
return;
}
int main(){
int a,b,c;
n=read();m=read();
for(int i=1;i<=n-1;++i){
a=read();b=read();c=read();
add_edge(a,b,c);add_edge(b,a,c);
}
for(int i=1;i<=m;++i) que[i]=read();
nmax=0x3f3f3f3f;sum=n;getrt(1,0);solve(1);
for(int i=1;i<=m;++i){
if(numb[i]) puts("AYE");
else puts("NAY");
}
return 0;
}