Tree（POJ 1741 树的点分治）

题目链接：

Tree

 

题意：

给定一棵树，每条边有一个权值，求树上长度 <=k 的路径条数。

 

思路：

树的点分治例题。

参考博客：【算法学习】点分治

计算一棵以 A 为根的树上长度 <=k 的路径条数可分为 2 个部分：

1. 路径经过 A 点。

2. 路径不经过 A 点。

可以看出第 2 种情况是以A的子树中的点为根节点时的情况 1 。所以每次计算以一个点为根时的第一种情况，dfs递归计算即可。

考虑经过 A 的边：A，A->B，A->B->D，A->B->E，A->C，A->C->F 。

上述 2 条边可以合成 1 条路径（因为有A这条相当于不存在的边，所以2条边合成的边中也包括了从A开始的链）。

把这些权值都存下来，排序，遍历这些权值（设当前为 i ），每次二分找到第一个与第 i 个相加大于 k 的位置 pos ，则有pos-i-1种情况满足和<=k。复杂度O(nlogn) 。

当然，上述计算的结果中包含非法情况，如 A->B 不能与 A->B->D 合成一条路径。这种情况都出现在 A 的一棵子树中两条边进行了组合。考虑去除非法的路径，对于根节点的每个子节点代表的子树，按照同样方式统计答案，并把得出的结果从原来的答案中减去即可。其中还要考虑子树的路径长度，刚才对根的计算时，子树的所有路径长都加上了根到子树的边的权值。那么在对这棵子树计算时，注意子树的路径也都要加上这条边的权值，这样正好和原来的路径长度吻合。设每棵子树大小为siz[i]，复杂度<= O(siz[1]*logn+siz[2]*logn+...+siz[t]*logn) <= O((siz[1]+siz[2]+...+siz[t])*logn) <= O(nlogn)

因此，这样对于以一个点为根节点的情况就可以在O(nlogn)的情况下求得了。

接下来求其所有子节点为根节点的情况。且其子节点求解时与该点无关。

但这样看来要求 n 个点，复杂度爆炸。点分治的关键来了，每次选的点为树的重心。

树的重心介绍见：树的重心

其满足一个性质：以树的重心为根的有根树，最大子树大小不超过  。

因此，我们每次找到树的重心作为根节点，计算答案。再把其所有子树按这种方法求解（因为其子节点求解时与该点无关）。

对于一个点所有子树（即树的一层）计算完的复杂度为O(nlogn)（证明方法同去除非法情况时的复杂度计算）

因为每次找的都是重心，因此最多计算 logn 层，因此总复杂度为 O(n*logn*logn) 。

 

总结：点分治，顾名思义就是每个点分别计算，但通过每次选取子树重心为新根来减小树的高度，从而来降低复杂度。是一种巧妙的暴力。

 

坑点再代码注释中给出。

 

Code：

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

typedef long long ll;

const int MAX = 10000 + 10;
const ll mod = 1e9 + 7;

typedef struct {
	int to, val;
}Point;

int n, k;
vector<Point>mp[MAX];
vector<int>num;
int siz[MAX], dis[MAX], vis[MAX];
int rt, minsubtree, nodenum;
int ans;

//求树的重心
void find_root(int root, int fa)
{
	siz[root] = 1;
	int maxsubtree = 0;
	for (int i = 0; i < mp[root].size(); i++) {
		int v = mp[root][i].to;
		if (v == fa)	continue;
		if (vis[v])	continue;
		find_root(v, root);
		siz[root] += siz[v];
		maxsubtree = max(maxsubtree, siz[v]);
	}
	//注意总节点个数不是一直为n
	maxsubtree = max(maxsubtree, nodenum - siz[root]);
	if (maxsubtree < minsubtree) {
		rt = root;
		minsubtree = maxsubtree;
	}
}

//求以一个点为根节点时经过它的所有边
void dfs(int root, int fa)
{
	for (int i = 0; i < mp[root].size(); i++) {
		int v = mp[root][i].to;
		if (v == fa)	continue;
		if (vis[v])	continue;
		dis[v] = dis[root] + mp[root][i].val;
		num.push_back(dis[v]);
		dfs(v, root);
	}
}

//计算以一个点为根节点时的答案（总：含非法情况）
int f()
{
	sort(num.begin(), num.end());
	ll sum = 0;
	int tot = num.size();
	for (int i = 0; i < tot - 1; i++) {
		if (num[i] >= k) {
			continue;
		}
		int pos = upper_bound(num.begin() + i + 1, num.end(), k - num[i]) - num.begin();
		sum += (pos - 1 - (i + 1) + 1);
	}
	return sum;
}

//计算以一个点为根节点时的答案（去除非法情况）
void cul(int root, int fa)
{
	num.clear();
	dis[root] = 0;
	num.push_back(0);
	dfs(root, fa);
	if (num.size() == 1)
		return;
	ans += f();
	for (int i = 0; i < mp[root].size(); i++) {
		int v = mp[root][i].to;
		if (v == fa)	continue;
		if (vis[v])	continue;
		num.clear();
		dis[v] = mp[root][i].val;
		num.push_back(dis[v]);
		dfs(v, root);
		ans -= f();
	}
}

//以每个点为根节点进行计算
void solve(int root, int fa)
{
	vis[root] = 1;
	cul(root, fa);
	for (int i = 0; i < mp[root].size(); i++) {
		int v = mp[root][i].to;
		if (v == fa)	continue;
		if (vis[v])	continue;
		minsubtree = 1e9 + 7;
		nodenum = siz[v];
		//每次取其子树的重心为根
		find_root(v, root);
		solve(rt, -1);
	}
}

int main()
{
	while (scanf("%d%d", &n, &k), n || k)
	{
		memset(vis, 0, sizeof(vis));
		//注意vector的初始化，RE就是忘了这个
		for (int i = 1; i <= n; i++) {
			mp[i].clear();
		}
		for (int i = 1; i < n; i++) {
			int u, v, w;
			scanf("%d%d%d", &u, &v, &w);
			Point tmp;
			tmp.to = v;
			tmp.val = w;
			mp[u].push_back(tmp);
			tmp.to = u;
			mp[v].push_back(tmp);
		}
		rt = 1;
		minsubtree = 1e9 + 7;
		ans = 0;
		nodenum = n;
		find_root(1, -1);
		solve(rt, -1);
		printf("%d\n", ans);
	}
	return 0;
}