BZOJ 1468 树分治

求出子树的重心后求出它每个子节点的距离，排序后就可以统计距离小于等于K的点对的个数了，但是会在同一子树内重复，然后在每个子树里面减去小于等于K的点对个数就可以了。

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 using namespace std;
 const int Maxn=;
 const int Inf=0x3f3f3f3f;
 int n,k,Root,u,v,w,Sum,Size[Maxn],Q[Maxn],F[Maxn],d[Maxn],cnt,head[Maxn],vis[Maxn],Top,Ans;
 struct EDGE{int to,next,w;}edge[Maxn<<];
 inline int Max(int x,int y) {return x>y?x:y;}
 inline void Add(int u,int v,int w) {edge[cnt].to=v;edge[cnt].next=head[u];edge[cnt].w=w;head[u]=cnt++;}
 void Get_Root(int u,int fa)
 {
     Size[u]=; F[u]=;
     for (int i=head[u];i!=-;i=edge[i].next)
     {
         int v=edge[i].to;
         if (v==fa || vis[v]) continue;
         Get_Root(v,u);
         Size[u]+=Size[v];
         F[u]=Max(F[u],Size[v]);
     }
     F[u]=Max(F[u],Sum-Size[u]);
     if (F[u]<F[Root]) Root=u;
 }
 void Get_Deep(int u,int fa)
 {
     Q[++Top]=d[u];
     for (int i=head[u];i!=-;i=edge[i].next)
     {
         int v=edge[i].to;
         if (v==fa || vis[v]) continue;
         d[v]=d[u]+edge[i].w;
         Get_Deep(v,u);
     }
 }
 int Calc(int u,int value)
 {
     d[u]=value; Top=; Get_Deep(u,);
     sort(Q+,Q+Top+);
     int l=,r=Top,Res=;
     while (l<=r)
     {
         if (Q[l]+Q[r]<=k)
             Res+=r-l,l++; else r--;
     }
     return Res;
 }
 void Work(int u)
 {
     Ans+=Calc(u,);  vis[u]=true;
     for (int i=head[u];i!=-;i=edge[i].next)
     {
         int v=edge[i].to;
         if (vis[v]) continue;
         Ans-=Calc(v,edge[i].w);
         Sum=Size[v]; Root=;
         Get_Root(v,u);
         Work(Root);
     }
 }
 int main()
 {
     while (scanf("%d%d",&n,&k)!=EOF)
     {
         if (n== && k==) break;
         Ans=; cnt=; memset(head,-,sizeof(head));
         for (int i=;i<n;i++)
         {
             scanf("%d%d%d",&u,&v,&w);
             Add(u,v,w),Add(v,u,w);
         }
         memset(vis,false,sizeof(vis));
         Sum=n; F[]=Inf;
         Get_Root(,);
         Work(Root);
         printf("%d\n",Ans);
     }
     return ;
 }

C++