P3806 【模板】点分治1（模板)

https://www.luogu.com.cn/problem/P3806

---

点分治还有边分治。暂时补个点分治。

感觉这个算dis的那部分和dsu on tree的暴力很类似阿。确实看到题解区里有一个用了dsu on tree的。

到时候都要重新理...

 

思路：

 

首先要考虑如何计算答案，对于每个距离，他要不经过当前的根节点，要不就是在根节点的子树里。我们算好当前经过根节点的所有距离并存下。然后递归，这样就能处理原来在根节点的子树里的距离（他们总会变成根的）。

算有无出现的距离就类似背包，dis[v]|=dis[v-x]。

这时候可能就会想到优雅的暴力dsu on tree。

 

这题学习点分治。

 

作为分治，它要先将树分开分别处理，再合起来处理。

为了保证复杂度，需要将树分得尽量平均，至少不能分出太大的部分。

树的重心有一个很好的性质：它的每一个子树的大小都不超过n/2 .那么可以logn的减少

于是得到点分治的步骤：

1. 找出树的重心。
2. 计算这棵树的贡献。
3. 对于重心的每一个子树，递归进行点分治。

复杂度：递归层数 O(logn)。如果第 2 步是O(n) 的，那么总复杂度O(nlogn)。

于是我们每次去跑树的重心。注意不跑一次，所以找重心的函数注意判vis[v]还有原来找一次是用n，这多次用sum来存当前子树的rt。

而且找完rt以后，我们要更新siz，因为现在要以该rt为根来算每个子树的siz。如果不这么做，其重心找的是错误的，复杂度其实是会被卡掉的。

板子题过了是数据水了可能。但是正确做法这样是不对的。

找重心的复杂度参考：https://liu-cheng-ao.blog.uoj.ac/blog/2969

 

#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
#include<cmath>
#include<map>
#include<set>
#include<cstdio>
#include<algorithm>
#define debug(a) cout<<#a<<"="<<a<<endl;
using namespace std;
const int maxn=1e4+10;
const int maxk=3e7+5;
typedef int LL;
inline LL read(){LL x=0,f=1;char ch=getchar();	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
LL n,m,rt,sum,cnt;/// rt记录重心，sum记录当前树大小，cnt是计数器
LL tmp[maxn],siz[maxn],dis[maxn],son[maxn],q[105];///tmp记录算出的距离，siz记录子树大小，dis[i]为rt与i之间的距离
/// maxp用于找重心，q用于记录所有询问
///judge[i]记录在之前子树中距离i是否存在，ans记录第k个询问是否存在，vis记录被删除的结点
bool judge[maxk],ans[105],vis[maxn];
struct Edge{
    LL to,cost;
};
vector<Edge>g[maxn];
inline void getroot(LL u,LL fa){
     siz[u]=1;son[u]=0;///son初始化为最小值
     for(LL i=0;i<g[u].size();i++){
         LL v=g[u][i].to;
         if(v==fa||vis[v]) continue;///被删掉的也不要算
         getroot(v,u);
         siz[u]+=siz[v];
         if(son[u]<siz[v]) son[u]=siz[v];
     }
     son[u]=max(son[u],sum-siz[u]);///注意这里是sum
     if((son[u]<<1)<=sum) rt=u;///更新重心
}
///计算各结点与根结点之间的距离并全部记录在tmp里
///感觉这里这么暴力去找就很像dsu on tree
inline void getdis(LL u,LL fa){
        tmp[++cnt]=dis[u];
        for(LL i=0;i<g[u].size();i++){
            LL v=g[u][i].to;LL cost=g[u][i].cost;
            if(vis[v]||v==fa) continue;
            dis[v]=dis[u]+cost;
            getdis(v,u);
        }
}
///! 注意judge数组要存放之前子树里存在的路径长度，排除折返路径的可能
inline void solve(LL u){
     static std::queue<LL>que;
     for(LL i=0;i<g[u].size();i++){
         LL v=g[u][i].to;LL cost=g[u][i].cost;
         if(vis[v]) continue;
         cnt=0;///清空
         dis[v]=cost;
         getdis(v,u);///把距离都处理出来
         for(LL j=1;j<=cnt;j++){
            for(LL k=1;k<=m;k++){///遍历所有询问
                if(q[k]>=tmp[j]){///如果询问大于单条路径长度，那就有可能存在
                   ans[k]|=judge[q[k]-tmp[j]];
                }
            }
         }
         for(LL j=1;j<=cnt;j++){///把存在的单条路径长度标上true，供下个子树用
             que.push(tmp[j]);
             judge[tmp[j]]=true;
         }
     }
     while(!que.empty()){///清空judge数组，不要用memset
           judge[que.front()]=false;
           que.pop();
     }
}
inline void divide(LL u){
     vis[u]=judge[0]=true;///删除根节点
     solve(u);///计算经过根节点的路径
     for(LL i=0;i<g[u].size();i++){///分治剩余部分
         LL v=g[u][i].to;
         if(vis[v]) continue;
         rt=0;///重心置为0
         son[rt]=sum=siz[v];///并把son[0]置为最大值
         getroot(v,0);
         getroot(rt,0);///与主函数相同，第二次更新siz大小
         divide(rt);
     }
}
int main(void){
   n=read();m=read();
   for(LL i=1;i<n;i++){
       LL u,v,w;u=read();v=read();w=read();
       g[u].push_back({v,w});g[v].push_back({u,w});
   }
   for(LL i=1;i<=m;i++) q[i]=read();
   son[0]=sum=n;///maxp[0]置为最大值（一开始rt=0）
   getroot(1,0);///找重心
   //! 此时siz数组存放的是以1为根时的各树大小，需要以找出的重心为根重算
   getroot(rt,0);
   divide(rt);///分治
   for(LL i=1;i<=m;i++){
       if(ans[i]) printf("AYE\n");
       else printf("NAY\n");
   }
   return 0;
}