点分治模板+学习总结

点分治是一种用来处理树上路径的算法，假如给出一个问题，有一颗树，树上有n个点，要求你求出这棵树上距离小于等于k点对的数量。

首先我们有一个最简单直观的想法，求出任意两点之间的距离，判断是否小于等于k，用搜索去写的话我们的时间复杂度是O(n^2)，这对于一些有着较大数据范围的题来说是不可接受的，这个时候点分治就出现了。

首先对于一颗有根树，满足条件的路径有两种情况：

第一种情况，满足条件的路径经过根节点，横跨两个不同的子树

第二种情况，满足条件的路径在根节点的一个子树当中

对于第一种情况我们可以O（n）的找出根节点到子树任意一点的距离，然后判断dis[v][root]+dis[u][root]是否小于等于k就行了，

对于第二种情况，我们可以在其子树中再找一个根节点，对这个子树单独求解，这样第二种情况就又变成第一种情况了

我们需要考虑各种能使我们算法时间复杂度退化的情况，也就是最坏的一些情况，对于树形结构来说，菊花图，链图以及菊花链图往往是我们最常考虑的特殊情况，很明显，如果按照之前所说，我们的时间复杂度在处理链图的时候时间复杂度就退化成了O(n^2),幸运的是，我们只要适当的选取根节点就能避免这种情况，以链图为例，我们每次取最大子树最小的点作为根节点，也就是树的重心作为根节点，而树的重心有一个特性就是mxson_size<=tree_size/2,由于这个特性，所以我们能保证我们的算法时间复杂度稳定在O(n*logn)

点分治算法还有一个非常重要的细节需要处理，我们判断的条件是dis[v][root]+dis[u][root]<=k,所以会出现下列的一种情况

假如我们的k=4，a+b=2,a+c=2,按照上述条件判断，则a+b+a+c是刚好等于k,满足我们的条件，因此会被计入答案，但是我们很容易就能发现，这一条路径是错误的，a这一条边被重复考虑了，对于这一种情况，我们可以通过容斥原理来解决，在计算root这一点的答案时，我们需要额外特殊地考虑一下儿子答案，儿子节点到其子树的路径视为，root节点到儿子节点所在子树的路径，其中满足条件的路径视为儿子答案，然后我们用总的答案减去儿子答案就行了。

代码：

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define ll long long
const int maxn=4e4+9;
struct Edge{
    int next,to,val;
}edge[maxn*2];
int cnt=0,vis[maxn],root,ans=0,k,mx=inf,Size,head[maxn],sz[maxn],q[maxn],r=0,d[maxn];
inline void add(int u,int v,int val){
    edge[cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].val=val;
    head[u]=cnt++;
}
void getroot(int u,int fa){
    sz[u]=1;int num=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].to;
        if(v!=fa&&!vis[v]){
            getroot(v,u);
            sz[u]+=sz[v];
            num=max(num,sz[v]);
        }
    }
    num=max(num,Size-sz[u]);
    if(num<mx)mx=num,root=u;
}
void getdis(int u,int fa){
    q[++r]=d[u];
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].to;
        if(v!=fa&&!vis[v]){
            d[v]=edge[i].val+d[u];
            getdis(v,u);
        }
    }
}
int cal(int u,int val){
    r=0,d[u]=val;
    getdis(u,0);
    int l=1,sum=0;
    sort(q+1,q+r+1);
    while(l<r){
        if(q[l]+q[r]<=k){
            sum+=r-l;
            l++;
        }
        else r--;
    }
    return sum;
}
void dfs(int u){
    vis[u]=1;
    ans+=cal(u,0);
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].to;
        if(!vis[v]){
            ans-=cal(v,edge[i].val);
            Size=sz[v];
            mx=inf;
            getroot(v,0);
            dfs(root);
        }
    }
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    memset(head,-1,sizeof(head));
    int i,j,n;
    cin>>n;
    for(i=0;i<n-1;i++){
        int x,y,z;cin>>x>>y>>z;
        add(x,y,z);add(y,x,z);
    }
    cin>>k;
    Size=n;
    mx=inf;
    getroot(1,0);
    dfs(root);
    cout<<ans<<endl;
}

模板题：https://www.luogu.org/problem/P4178