POJ 1741 Tree(树上点分治)

最新推荐文章于 2019-08-21 21:57:49 发布

原创最新推荐文章于 2019-08-21 21:57:49 发布 · 220 阅读

0 ·

CC 4.0 BY-SA版权

分治专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种算法，用于计算给定树中任意两点之间的最短距离，并统计这些距离不超过给定阈值的有效点对数量。该算法首先寻找树的重心，然后递归地分解问题并计算每部分的有效点对。

Tree

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 28073		Accepted: 9355

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

Sample Output

#include<cstdio>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=10004;
struct node
{
    int to,cost;
};
vector<node>G[maxn];
vector<int>dep;
int n,k,root,son[maxn],f[maxn],len,ans,vis[maxn],d[maxn];
void getroot(int v,int fa)//找树的重心
{
    f[v]=son[v]=0;
    for(int i=0;i<G[v].size();i++)
    {
        node e=G[v][i];
        if(e.to==fa||vis[e.to])continue;
        getroot(e.to,v);
        son[v]+=son[e.to]+1;
        f[v]=max(f[v],son[e.to]+1);
    }
    f[v]=max(f[v],len-son[v]-1);
    if(f[v]<f[root])
        root=v;
}
void getdep(int st,int fa)
{
    dep.push_back(d[st]);
    for(int i=0;i<G[st].size();i++)
    {
        node e=G[st][i];
        if(e.to==fa||vis[e.to])continue;
        d[e.to]=d[st]+e.cost;
        getdep(e.to,st);
    }
}
int cal(int st,int cost)
{
    dep.clear();
    d[st]=cost;
    getdep(st,0);
    sort(dep.begin(),dep.end());
    int res=0,l=0,r=dep.size()-1;
    while(r>l)
    {
        if(dep[r]+dep[l]<=k)
            res=res+r-l,l++;
        else r--;
    }
    return res;
}
void work(int st)
{
    ans+=cal(st,0);
    vis[st]=1;
    for(int i=0;i<G[st].size();i++)
    {
        node e=G[st][i];
        if(vis[e.to])continue;
        ans-=cal(e.to,e.cost);//去重
        root=0;f[0]=len=son[e.to]+1;
        getroot(e.to,0);
        work(root);
    }
}
int main()
{
    while(~scanf("%d%d",&n,&k))
    {
        if(n==0&&k==0)break;
        ans=0;
        for(int i=0;i<=n;i++)
            G[i].clear();
        memset(vis,0,sizeof(vis));
        for(int i=1;i<n;i++)
        {
            int x,y,z;scanf("%d%d%d",&x,&y,&z);
            G[x].push_back((node){y,z});
            G[y].push_back((node){x,z});
        }
        len=n;f[0]=n;
        getroot(1,root=0);
        work(root);
        printf("%d\n",ans);
    }
    return 0;
}