Poj 1741 Tree 点分治 解题报告

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

思路

其实我基本就不会点分治。。

发现确实比链分治简单不少，所谓点分治 对于一条树路径 只有经过或不经过一个点的情况。

对于不经过的情况 把一棵树按这个点拆成好几棵分治就行了，考虑经过这个点的情况，对于这题 可以对这个点延伸出的几棵子树各做一次dfs，记录子树中出现的距离值。
对于一棵树的距离值数组，把它排序求一次ans1，再对每棵子树分别求一个自己对自己的ans2，ans1−∑ans2ans1−∑ans2即为最后的ans

代码

借鉴黄学长，hzwer那么有名我就不贴网址了。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int INF=0x7fffffff;
const int N=10000+5;
using namespace std;
int n,k,num,sum,ans,root;
int head[N],deep[N],d[N],f[N],son[N],vis[N];
struct edge
{
    int u,next,v;
};
edge ed[N*3];
void build(int u,int v,int w)
{
    ed[++num].u=v;
    ed[num].next=head[u];
    head[u]=num;
    ed[num].v=w;
}
void insert(int u,int v,int w)
{
    build(u,v,w);
    build(v,u,w);
}
void getroot(int x,int fa)
{
    son[x]=1;f[x]=0;
    for (int i=head[x];i;i=ed[i].next)
    {
        if (ed[i].u==fa||vis[ed[i].u]) continue;
        getroot(ed[i].u,x);
        son[x]+=son[ed[i].u];
        f[x]=max(f[x],son[ed[i].u]);
    }
    f[x]=max(f[x],sum-son[x]);
    if (f[x]<f[root]) root=x;
}
void getdeep(int x,int fa)
{
    deep[++deep[0]]=d[x];
    for (int i=head[x];i;i=ed[i].next)
    {
        if (ed[i].u==fa||vis[ed[i].u]) continue;
        d[ed[i].u]=d[x]+ed[i].v;
        getdeep(ed[i].u,x);
    }
}
int cal(int x,int now)
{
    d[x]=now;deep[0]=0;
    getdeep(x,0);
    sort(deep+1,deep+deep[0]+1);
    int t=0,l,r;
    for (l=1,r=deep[0];l<r;)
    {
        if (deep[l]+deep[r]<=k){t+=r-l;l++;}
        else r--;
    }
    return t;
}
void work(int x)
{
    ans+=cal(x,0);
    vis[x]=1;
    for (int i=head[x];i;i=ed[i].next)
    {
        if (vis[ed[i].u]) continue;
        ans-=cal(ed[i].u,ed[i].v);
        sum=son[ed[i].u];
        root=0;
        getroot(ed[i].u,root);
        work(root);
    }
}
int main()
{
    while(true)
    {
        ans=0;root=0;num=0;
        memset(vis,0,sizeof(vis));
        memset(head,0,sizeof(head));
        scanf("%d%d",&n,&k);
        if (n==0) break;
        for (int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            insert(u,v,w);
        }
        sum=n;f[0]=INF;
        getroot(1,0);
        work(root);
        printf("%d\n",ans);
    }
    return 0;
}