POJ 1741 树的点分治

    对于树上的路径问题，一种高效的处理方式就是分治算法。关于树分治算法的研究，详见2009年IOI国家集训队论文——《分治算法在树的路径问题中的应用》。
    通常对于树上的分治算法有两种，第一种是针对点进行的分治，另一种是针对边进行的分治，可以证明，大部分情况下点分治算法的性能更加稳定，而边分治在某些情况下，算法效率非常低。所以以下主要讨论点分治。
    如POJ-1741,求解一棵树中路径长度不大于K的有多少点对。
    对于一棵有根树，树中满足对所对应的一条路径，必然是以下两种情况之一：
    1.经过根节点
    2.路径在以根节点某个儿子为根的一棵子树中
    对于情况2，可以递归求解，下面主要来考虑情况1.
    那么对于这道题的情况1，设dis[i]为节点i到根的距离，我们就是要求解有多少对经过根的路径，那么问题等价于能找到多少对不同的点对(i,j)，使得dis[i]+dis[j]<=k，而且i和j要属于以当前根的两个不同的儿子为根的子树中。
    将问题转化以下，就可以发现所求结果等价于在一棵有根树中找到的点对数x-在以当前根的儿子为根的子树所找到的点对数。
    求X、Y的过程均可以转化为以下问题：已知A[1],A[2],...A[m]，求满足i<j且A[i]+A[j]<=K的数对(i,j)的个数。这个问题可以通过排序之后，线性方法求解。
    需要注意的是，这里所有到根的距离dis和重心都是对于某一次子树的根而言的，并不是一遍预处理得到的，而是每次递归分治成若干子树后，都要遍历当前的子树的所有节点再次求一遍dis和重心，一直递归下去。这里对于每一层子树都认为有n个节点，对于n个节点求重心和dis复杂度O(n)，求点对数需要O(nlogn)，这里假设递归一共进行L层，则算法复杂度为O(n*L*logn)。
    为了使算法不退化，必须每次选择的树的重心作为根，具体证明在论文中都有，这样的算法复杂度为O(n*logn*logn)。
    附上POJ-1741的ac代码。
   

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int MAXN = 1e4 + 10;

struct node {
    int v, w;
};

int n, k, root, Max, ans;
vector <node> tree[MAXN];
vector <int> dis;
int sz[MAXN], maxv[MAXN];
bool vis[MAXN];

void init() {
    memset(vis, false, sizeof(vis));
    for (int i = 1; i <= n; i++) tree[i].clear();
}

void dfs_size(int u, int pre) {         // 求出每个子树的大小，以及每个节点的最大儿子
    sz[u] = 1; maxv[u] = 0;
    int cnt = tree[u].size();
    for (int i = 0; i < cnt; i++) {
        int v = tree[u][i].v;
        if (v == pre || vis[v]) continue;
        dfs_size(v, u);
        sz[u] += sz[v];
        maxv[u] = max(maxv[u], sz[v]);
    }
}

void dfs_root(int r, int u, int pre) {  // 找出以u为根的子树的重心
    maxv[u] = max(maxv[u], sz[r] - sz[u]);
    if (Max > maxv[u]) {
        Max = maxv[u];
        root = u;
    }
    int cnt = tree[u].size();
    for (int i = 0; i < cnt; i++) {
        int v = tree[u][i].v;
        if (v == pre || vis[v]) continue;
        dfs_root(r, v, u);
    }
}

void dfs_dis(int u, int pre, int d) {    // 求出当前子树中所有点到根的距离
    dis.push_back(d);
    int cnt = tree[u].size();
    for (int i = 0; i < cnt; i++) {
        int v = tree[u][i].v, w = tree[u][i].w;
        if (v == pre || vis[v]) continue;
        dfs_dis(v, u, d + w);
    }
}

int cal(int u, int d) {         // 计算当前子树中合法的点对数
    int res = 0;
    dis.clear(); dfs_dis(u, -1, d);
    sort (dis.begin(), dis.end());
    int i = 0, j = dis.size() - 1;
    while (i < j) {
        while (dis[i] + dis[j] > k && i < j) --j;
        res += j - i;
        ++i;
    }
    return res;
}

void dfs(int u) {               // 总的dfs求解
    Max = n;
    dfs_size(u, -1); dfs_root(u, u, -1);
    ans += cal(root, 0);
    vis[root] = true;
    int cnt = tree[root].size(), rt = root; // 一定要注意这样里的root是全局变量，在递归之后可能改变，需要提前保存下来。
    for (int i = 0; i < cnt; i++) {
        int v = tree[rt][i].v, w = tree[rt][i].w;
        if (vis[v]) continue;
        ans -= cal(v, w);
        dfs(v);
    }
}

int main() {
    //freopen("in", "r", stdin);
    while (scanf("%d%d", &n, &k), n || k) {
        init();
        for (int i = 1; i < n; i++) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            tree[u].push_back((node){v, w});
            tree[v].push_back((node){u, w});
        }
        ans = 0;
        dfs(1);
        printf("%d\n", ans);
    }
    return 0;
}