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

---

思路：
点分治的经典题，看着黄学长的代码打出来的，很弱啊......
这题是求路径小于k的路径个数，如果暴力枚举对于1e5个结点肯定是要超时的。
这题能用点分治的原因是：对于某个点，所有的路径的要么经过它，要么不经过，因此我们只用处理经过当前节点的路径，因此可以基于点来分治。
点分治算法大致是：
1.无根树转化为有根树
　　找到树的重心（重心即以该点为根其子树中拥有最大结点数的那颗的子树是最小的）作为根结点，保证了树的层数最小。
2.递归处理根的子树

Code:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
using namespace std;
#define INF 0x3f3f3f3f
#define M(a, b) memset(a, b, sizeof(a))
const int maxn = 1e5 + 5;
int n, k, root, sum, ans, d[maxn], deep[maxn], son[maxn], f[maxn];
bool vis[maxn];
struct node {
    int to, w;
};
vector<node> G[maxn*2];

void getroot(int x, int fa) {
    son[x] = 1; f[x] = 0;
    for (int i = 0; i < G[x].size(); ++i) {
        int v = G[x][i].to;
        if (v == fa || vis[v]) continue;
        getroot(v, x);
        son[x] += son[v];
        f[x] = max(f[x], son[v]);
    }
    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 = 0; i < G[x].size(); ++i) {
        int v = G[x][i].to;
        if (v == fa || vis[v]) continue;
        d[v] = d[x] + G[x][i].w;
        getdeep(v, x);
    }
}

int cal(int x, int now) {
    int temp = 0, l, r;
    d[x] = now, deep[0] = 0;
    getdeep(x, 0);
    sort(deep+1, deep+1+deep[0]);
    l = 1, r = deep[0];
    while (l < r) {
        if (deep[l]+deep[r] <= k) {temp += r-l; l++;}
        else r--;
    }
    return temp;
}

void work(int x) {
    ans += cal(x, 0);
    vis[x] = 1;
    for (int i = 0; i < G[x].size(); ++i) {
        int v = G[x][i].to;
        if (vis[v]) continue;
        ans -= cal(v, G[x][i].w);
        sum = son[v];
        root = 0;
        getroot(v, 0);
        work(root);
    }
}

int main() {
    ios::sync_with_stdio(false);
    while(cin >> n >> k, n || k) {
        memset(vis, 0, sizeof(vis));
        int a, b, c;
        for (int i = 1; i < n; ++i) {
            cin >> a >> b >> c;
            G[a].push_back(node{b, c});
            G[b].push_back(node{a, c});
        }
        root = 0; ans = 0; 
        sum = n; f[0] = INF;
        getroot(1, 0);
        work(root);
        cout << ans << endl;
        for (int i = 0; i <= n; ++i) G[i].clear();
    } 

    return 0;
}