POJ 1741 Tree 点分树题解

Openjudge原题链接

POJ原题链接

• 题意
  输入树的各边及其长度，求路径小于等于k的点对数目

• 题解
  目标：寻找长度小于等于k的路径
  首先选取一个点作为根节点，那么路径只有两种情况：经过根节点；不经过根节点
  如果不经过根节点，那么一定经过最小公共子树的根节点，划归为问题1，可分治求解。

• 假定我们已经有了根节点和树的结构，那么只需要进行一次dfs，在dfs过程中求出每个节点到根节点的距离deep，以及计算出deep[x] + deep[y] <= k的pair数目，然后删除根节点，然后进入每一个子树重新计算新的deep并计算数目。但这样会重复计算。所以在第一次计算时应当减去属于同一棵子树的pair。

• 但是，如果树退化成一条链，那么时间复杂度为O(N ^ 2)。所以需要每次巧妙地选择根节点使得最大的子树最小。即选择重心, 这样保证树的高度不超过O(logN)。

• 更多解释参见代码注释

• 总的时间复杂度为O(N(logN)^2)

• 参考了ACMonster的解释和wwwiskey的解题思路

• 参考了关于点分治的理解-chty

• 参考了分治算法在树的路径问题中的应用——IOI2009中国国家集训队论文

• AC代码如下

#if 0
要寻找长度小于等于k的路径
首先选取一个点作为根节点，那么路径只有两种情况：
1.经过根节点
2.不经过根节点
如果不经过根节点，那么一定经过最小公共子树的根节点，划归为问题1，可分治求解。

假定我们已经有了根节点和树的结构，那么只需要进行一次dfs，在dfs过程中求出每个节点到根节点的距离deep，以及
计算出deep[x] + deep[y] <= k的pair数目，然后删除根节点，然后进入每一个子树重新计算新的deep并计算数目。但这
样会重复计算。所以在第一次计算时应当减去属于同一棵子树的pair。

但是，如果树退化成一条链，那么时间复杂度为O(N ^ 2)。所以需要每次巧妙地选择根节点使得最大的子树最小。即选择
重心, 这样保证树的高度不超过O(logN)。


以下是选择重心的源码。
void getroot(int x, int fa)//x表示当前结点，fa表示x的父结点
{
    son[x] = 1; F[x] = 0;//F数组记录以x为根的最大子树的大小
    for (int i = Link[x]; i; i = e[i].next)
        if (e[i].y != fa && !vis[e[i].y])//避免陷入死循环
        {
            getroot(e[i].y, x);//得到子结点信息
            son[x] += son[e[i].y];//计算x结点大小
            F[x] = max(F[x], son[e[i].y]);//更新F数组
        }
    F[x] = max(F[x], sum - son[x]);//sum表示当前树的大小，因为以x为根的情况还要考虑以x的父亲为根的子树大小。
    if (F[x]
#include
#include
#include
#include
#define MAXN 10005
using namespace std;
struct Edge {
    int v, l;//v表示连接到的下一个节点，l表示长度
    Edge(int v_, int l_) :v(v_), l(l_) {};
};
vector g[MAXN];//用变长数组存储图
vector dep;    //用来计算在某图下，以某个节点作为根节点时的各子节点的deep，它不需要知道具体是哪个子节点
int dist[MAXN];     //
int n, k;
int vis[MAXN];
int f[MAXN];//存储在当前图下,以某个节点作为根节点时，得到的最大子树的大小
int root;   //当前找到的根节点
int ans;    //最后要求的配对数目
int s[MAXN];//s for size，记录在当前图下每个节点的子树大小之和，包括自己
int totalNodes;//n-删除的点的个数
void getroot(int now, int fa) {
    int u;
    //s的存在是为了累加，然后得出父节点等所有祖先构成子树的大小
    s[now] = 1;//自己
    f[now] = 0;//存储每个节点的最大子树
    for (int i = 0; i < g[now].size(); i++) {//不会陷入死循环的原因之一：树上存在叶节点（只与父节点相连）
        u = g[now][i].v;//子节点
        if (u != fa && !vis[u]) {//不是父节点且未被切除，如果不排除父节点会陷入死循环
            getroot(u, now);//递归地找到子树的最大子树和子树的大小
            s[now] += s[u]; //加入子树的大小
            f[now] = max(f[now], s[u]);//找最大子树
        }
    }
    f[now] = max(f[now], totalNodes - s[now]);//把父节点等所有祖先当作一棵子树
    if (f[now] < f[root]) root = now;//找最大子树最小的根节点
}
void getdep(int now, int fa) {//在某个图某个根节点下求deep，天然的深度是dist[now]
    int u;
    dep.push_back(dist[now]);
    s[now] = 1;
    for (int i = 0; i < g[now].size(); i++) {
        u = g[now][i].v;
        if (u != fa && !vis[u]) {
            dist[u] = dist[now] + g[now][i].l;
            getdep(u, now);
            s[now] += s[u];
        }
    }
}
int calc(int now, int len) {//在减去属于同一棵子树的时候,len是这个子树到原根节点的距离
                            //我们把这个距离考虑进来，
    dep.clear();
    dist[now] = len;//以dist[now]作为基础求deep
    getdep(now, 0);//在当前图当前根节点下，计算每个子节点的deep,放入dep数组
    sort(dep.begin(), dep.end());
    int cnt = 0;//统计数目
    int l = 0, r = dep.size() - 1;
    /*
    用l表示左指针，r表示右指针，i从左向右遍历。
    如果dep[i]+dep[j]≤k，则点对(i,t)(i> n >> k) {
        if (!n && !k) break;
        for (int i = 0; i <= n; i++)
            g[i].clear();
        memset(vis, 0, sizeof(vis));
        int u, v, l;
        for (int i = 1; i < n; i++) {//读入n-1条边
            cin >> u >> v >> l;
            g[u].push_back(Edge(v, l));
            g[v].push_back(Edge(u, l));
        }
        f[0] = n;
        root = 0;
        totalNodes = n;
        getroot(1, 0);
        ans = 0;
        work(root);
        cout << ans << endl;
    }
}