poj1741 树分治

题目链接
Tree
Time Limit: 1000MS Memory Limit: 30000K
Total Submissions: 22430 Accepted: 7403
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

LouTiancheng@POJ
题意：给一棵有边权的树，问点对距离小于K的对数有多少。
经典的树分治，每一次求树的重心，然后将以重心为树根的子树的每个点到重心的距离求出来，放到一个数组中，从小到大排个序，然后用两个指针一个在最左，一个在最右，如果dis【i】+dis【j】>K就j–，右边指针向左移动，直到dis【i】+dis【j】<=K，停止j的左移，那么此时，点对（i，i+1），（i，i+2）。。。（i，j）都是小于K的，然后ans+=j-i；
然后i右移一位，然后继续重复j–的操作，直到i==j停止。但是这样会多算一部分

如图，仅看dis数组的话，点对距离等于K的有（因为解释起来一样）
（1，6）
（5，3）
（5，4）
（2，3）
（2，4）
（5，2）
我们发现后面三对是不对的，要想办法减去他们，我们发现，只有通过root点的点对是正确的，而在子树里打转形成的都是假的点对，那么我们可以分别把root 的子树上的每个点到root 的距离算出来，然后利用同样的方法，仅仅在子树上计算点对和等于K的数量，然后减去他们就行了，
因为子树上的点对和等于K的就是在子树中打转的那些点对。
树的重心简单一些，就不讲了，每次求完树的重心，用过后，标记该点已经使用，那么这时候树就被分成两个子树了，然后再分，就4，8，16.。。。。
这就是树的分治，（树上二分，hahah）
看我的代码吧：：

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <math.h>
#include <string.h>
using namespace std;
const int MAXN=50005;
int n,m,k;
struct node
{
    int to,next,l;
}edge[MAXN*2];
int head[MAXN],tot;

void addedge(int u,int v,int l)
{
    edge[tot].to=v;
    edge[tot].l=l;
    edge[tot].next=head[u];
    head[u]=tot++;
}
int root,num,ans,min_root;
int vis[MAXN],son[MAXN],max_son[MAXN];
int dis[MAXN];
void init()
{
    tot=0;
     ans=0;
    memset(head,-1,sizeof(head));
     memset(vis,0,sizeof(vis));
}
void dfs_size(int u,int fa)
{
    int v;
    son[u]=1;
    max_son[u]=0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(vis[v]||v==fa)
            continue;
        dfs_size(v,u);
        son[u]+=son[v];
        if(max_son[u]<son[v])
            max_son[u]=son[v];
    }
}
void dfs_root(int r,int u,int fa)
{
    int v;
    max_son[u]=max(max_son[u],son[r]-son[u]);
    if(max_son[u]<min_root)
    {
        min_root=max_son[u];
        root=u;
    }
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(vis[v]||v==fa)
            continue;
        dfs_root(r,v,u);
    }
}
void dfs_dis(int u,int d,int fa)
{
    int v;
    dis[num++]=d;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(vis[v]||v==fa)
            continue;
        dfs_dis(v,d+edge[i].l,u);
    }
}
int cal(int u,int d)
{
    int res=0;
    num=0;
    dfs_dis(u,d,-1);
    sort(dis,dis+num);
    int i=0,j=num-1;
    while(i<j)
    {
        while(dis[i]+dis[j]>k&&i<j)
            j--;
        res+=j-i;
        i++;
    }
    return res;
}
void dfs(int u)
{
    int v;
    min_root=n;
    dfs_size(u,-1);
    dfs_root(u,u,-1);
    ans+=cal(root,0);
    vis[root]=1;
    for(int i=head[root];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(!vis[v])
        {
            ans-=cal(v,edge[i].l);
            dfs(v);
        }


    }
}
int main()
{
    int u,v,l;
    while(scanf("%d%d",&n,&k)!=-1)
    {
        if(n==0&&k==0)
            break;
            init();
        for(int i=0;i<n-1;i++)
        {
            scanf("%d%d%d",&u,&v,&l);
            addedge(u,v,l);
            addedge(v,u,l);
        }

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

    return 0;
}