POJ 1741 Tree （男人八题 - 树分治[点分]）

题意：

树上n 个点， 求有多少点对满足距离不超过K

思路：

树上点分治 入门题目。

我们每次递归 都要从这棵树的重心开始递归。  从这个点这出其他点到这个点距离来， 然后我们看看有几个点对 距离和满足小于等于K， 这肯定是一部分贡献， 但是有个问题， 这样计算，只有 一个点在一个子树，另一个点在另一个子树才能满足这个距离公式， 如果同在一棵子树， 那么显示式子不成立， 所以，我们需要把这个重心所有子树的符合条件的答案减去。

所以问题转换成了 

找重心， 计算距离， 统计答案。

简单说一下重心， 一棵树的重心就是这个树上的一个点， 使得 这个点的最大后代数量最小的点。

吐槽：

重心开的全局变量， 因为每次还要找root 的孩子， 忘记把这个转到局部变量了， debug了一小时= =

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

const int maxn = 10000 + 5;

vector<pair<int,int> >g[maxn];

long long ans;
int vis[maxn];
int n,K;
int siz[maxn], mx[maxn];

void getsize(int cur,int fa){
    siz[cur] = 1;
    mx[cur] = 0;
    for (int i = 0; i < g[cur].size(); ++i){
        int v = g[cur][i].first;
        if (v != fa && !vis[v]){
            getsize(v, cur);
            siz[cur] += siz[v];
            if (siz[v] > mx[cur]) mx[cur] = siz[v];
        }
    }
}

int root;
int mi;

void findroot(int rt, int cur, int fa){
    mx[cur] = max(mx[cur], siz[rt] - siz[cur]);
    if (mx[cur] < mi){
        mi = mx[cur];
        root = cur;
    }

    for (int i = 0; i < g[cur].size(); ++i){
        int v = g[cur][i].first;
        if (v != fa && !vis[v]){
            findroot(rt, v, cur);
        }
    }

}

int cnt;
int Dis[maxn];

void getdis(int cur,int d,int fa){

    Dis[cnt++] = d;

    for (int i = 0; i < g[cur].size(); ++i){
        int v = g[cur][i].first;
        int w = g[cur][i].second;

        if (v != fa && !vis[v]){
            getdis(v, d + w, cur);
        }
    }
}

long long solve(int root,int d){
    cnt = 0;
    getdis(root, d,0);
    sort(Dis, Dis + cnt);
    long long ret = 0;
    int i = 0, j = cnt-1;
    while(i < j){
        while(i < j && Dis[j] + Dis[i] > K)--j;
        ret += j - i;
        i++;
    }
    return ret;
}

void dfs(int cur){
    getsize(cur, 0);
    mi = 0x3f3f3f3f;
    findroot(cur, cur, 0);
    long long tmp = solve(root, 0);
    ans += tmp;
    vis[root] = 1;
    int mu = root;
    for (int i = 0; i < g[mu].size(); ++i){
        int v = g[mu][i].first;
        int w = g[mu][i].second;
        if (!vis[v]){
            long long tmp2 = solve(v,w);
            ans -= tmp2;
            dfs(v);
        }
    }
}
int main(){
    while(~scanf("%d %d",&n, &K) && (n || K)){
        memset(vis,0,sizeof vis);
        for (int i = 1; i <= n;++i)g[i].clear();
        for (int i = 1; i < n; ++i){
            int u,v,w;
            scanf("%d%d%d",&u, &v, &w);
            g[u].push_back(make_pair(v, w));
            g[v].push_back(make_pair(u, w));
        }
        ans = 0;
        dfs(1);
        printf("%lld\n", ans);
    }
    return 0;
}

Tree Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 23348   Accepted: 7737 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

[Submit]   [Go Back]   [Status]   [Discuss]