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;}