首先講解一下樹分治，以下的內容轉自：http://blog.sina.com.cn/s/blog_6d5aa19a0100o73m.html

對於一棵有根樹， 樹中滿足要求的一個數對所對應的一條路徑，必然是以下兩種情況之一：
1、經過根節點
2、不經過根節點，也就是說在根節點的一棵子樹中
對於情況2，可以遞迴求解，下面主要來考慮情況1。

設點i的深度為Depth[i]，父親為Parent[i]。
若i為根，則Belong[i]=-1，若Parent[i]為根，則Belong[i]=i，否則Belong[i]=Belong[Parent[i]]。
這三個量都可以通過一次BFS求得。
我們的目標是要統計：有多少對(i,j)滿足i<j，Depth[i]+Depth[j]<=K且Belong[i]<>Belong[j]

如果這樣考慮問題會變得比較麻煩，我們可以考慮換一種角度：
設X為滿足i<j且Depth[i]+Depth[j]<=K的數對(i,j)的個數
設Y為滿足i<j，Depth[i]+Depth[j]<=K且Belong[i]=Belong[j]數對(i,j)的個數
那麼我們要統計的量便等於X-Y

求X、Y的過程均可以轉化為以下問題：
已知A[1],A[2],...A[m]，求滿足i<j且A[i]+A[j]<=K的數對(i,j)的個數

對於這個問題，我們先將A從小到大排序。
設B[i]表示滿足A[i]+A[p]<=K的最大的p(若不存在則為0)。我們的任務便轉化為求出A所對應的B陣列。那麼，若B[i]>i，那麼i對答案的貢獻為B[i]-i。
顯然，隨著i的增大，B[i]的值是不會增大的。利用這個性質，我們可以線上性的時間內求出B陣列，從而得到答案。

綜上，設遞迴最大層數為L，因為每一層的時間複雜度均為“瓶頸”——排序的時間複雜度O(NlogN)，所以總的時間複雜度為O(L*NlogN)

然而，如果遇到極端情況——這棵樹是一根鏈，那麼隨意分割勢必會導致層數達到O(N)級別，對於N=10000的資料是無法承受的。因此，我們在每一棵子樹中選擇“最優”的點分割。所謂“最優”，是指刪除這個點後最大的子樹儘量小。這個點可以通過樹形DP在O(N)時間內求出，不會增加時間複雜度。這樣一來，即使是遇到一根鏈的情況時，L的值也僅僅是O(logN)的。

簡單來說：點分治就是每次找到重心，然後把重心去掉，對分成的每兩棵樹之間分別統計路徑資訊（以重心的每個相鄰點為根，遍歷整棵子樹即可得到這個根到每個結點的統計資訊），就可以知道包含這個重心的所有路徑的資訊，然後對於剩下的路徑就是在子樹裡面進行同樣的操作了，直到只剩一個點為止（注意這一個點所構成的路徑有時也要處理一下）。邊分治就是每次找到一條邊，使得刪掉這條邊後分成的兩棵子樹大小盡可能平均，然後以刪掉的邊的兩端點為根，分別統計根到兩棵樹中的每個結點的路徑資訊，最後合併算路徑，即可得到包含這條邊的所有路徑的資訊，剩下的路徑在兩棵樹中遞迴處理。

對於樹分治可以參考qzc大神的論文：

《分治演算法在樹的路徑問題中的應用》


Tree

Time Limit: 1000MS	Memory Limit: 30000K
Total Submissions: 12417	Accepted: 3939

Description

Give a tree with n vertices,each edge has a length(positive integer less than 1001).
Define dist(u,v)=The min distance between node u and v.
Give an integer k,for every pair (u,v) of vertices is called valid if and only if dist(u,v) not exceed k.
Write a program that will count how many pairs which are valid for a given tree.

Input

The input contains several test cases. The first line of each test case contains two integers n, k. (n<=10000) The following n-1 lines each contains three integers u,v,l, which means there is an edge between node u and v of length l.
The last test case is followed by two zeros.

Output

For each test case output the answer on a single line.

Sample Input

5 4
1 2 3
1 3 1
1 4 2
3 5 1
0 0

Sample Output

8

Source

題意：找出樹中有多少點對，滿足dis（u，v）<K

思路：點分治模板題

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=10010;
int N,K;
int ans,root,Max;
struct node
{
    int v,next,w;
}edge[maxn*2];
int head[maxn],tot;
int size[maxn];//樹的大小
int maxv[maxn];//最大孩子節點的size
int vis[maxn];
int dis[maxn];
int num;
void init()
{
    tot=0;
    ans=0;
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
}
void add_edge(int u,int v,int w)
{
    edge[tot].v=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}
//處理子樹的大小
void dfssize(int u,int f)
{
    size[u]=1;
    maxv[u]=0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==f||vis[v])continue;
        dfssize(v,u);
        size[u]+=size[v];
        if(size[v]>maxv[u])maxv[u]=size[v];
    }
}
//找重心
void dfsroot(int r,int u,int f)
{
    if(size[r]-size[u]>maxv[u])//size[r]-size[u]是u上面部分的樹的尺寸，跟u的最大孩子比，找到最大孩子的最小差值節點
        maxv[u]=size[r]-size[u];
    if(maxv[u]<Max)Max=maxv[u],root=u;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==f||vis[v])continue;
        dfsroot(r,v,u);
    }
}
//求每個點離重心的距離
void dfsdis(int u,int d,int f)
{
    dis[num++]=d;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v!=f&&!vis[v])
            dfsdis(v,d+edge[i].w,u);
    }
}
//計算以u為根的子樹中有多少點對的距離小於等於K
int calc(int u,int d)
{
    int ret=0;
    num=0;
    dfsdis(u,d,0);
    sort(dis,dis+num);
    int i=0,j=num-1;
    while(i<j)
    {
        while(dis[i]+dis[j]>K&&i<j)j--;
        ret+=j-i;
        i++;
    }
    return ret;
}
void dfs(int u)
{
    Max=N;
    dfssize(u,0);
    dfsroot(u,u,0);
    ans+=calc(root,0);
    vis[root]=1;
    for(int i=head[root];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(!vis[v])
        {
            ans-=calc(v,edge[i].w);
            dfs(v);
        }
    }
}
int main()
{
    while(scanf("%d%d",&N,&K)!=EOF)
    {
        if(!N&&!K)break;
        int u,v,w;
        init();
        for(int i=1;i<N;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }

        dfs(1);
        printf("%d\n",ans);
    }
    return 0;
}