poj 1741 Tree 树的点分治

Tree

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 24394		Accepted: 8120

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

点分治模板题。

如果以根节点搜索，那么所有路径只有两种情况：经过根节点和不经过根节点。

但是如何减去不经过根节点的情况？如果不经过当前根节点，那么一定经过点对的最小公共根节点，这样减去以那一根节点所得出的结果。因此需要不断以子树的重心作为根进行分治。

每更新节点后，更新子树上所有节点的深度即到根节点的距离，然后排序统计满足条件的点对。

因为每次都是以重心作为根节点，所以复杂度不高。

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
const int maxm = 100005;
struct node
{
	int v, len, next;
}edge[maxm * 4];
int head[maxm * 4], vis[maxm], son[maxm], deep[maxm], s[maxm], d[maxm];
int root, n, m, cnt, tot, ans, sn;
void add(int u, int v, int w)
{
	edge[cnt].v = v, edge[cnt].len = w, edge[cnt].next = head[u], head[u] = cnt++;
	edge[cnt].v = u, edge[cnt].len = w, edge[cnt].next = head[v], head[v] = cnt++;
}
void getroot(int k, int pre)
{
	s[k] = 0, son[k] = 1;
	for (int i = head[k];i != -1;i = edge[i].next)
	{
		int v = edge[i].v;
		if (vis[v] || v == pre) continue;
		getroot(v, k);
		son[k] += son[v], s[k] = max(s[k], son[v]);
	}
	s[k] = max(s[k], sn - s[k]);
	if (s[root] > s[k]) root = k;
}
void getdeep(int k, int pre)
{
	d[++tot] = deep[k];
	for (int i = head[k];i != -1;i = edge[i].next)
	{
		int v = edge[i].v;
		if (v == pre || vis[v]) continue;
		deep[v] = deep[k] + edge[i].len;
		getdeep(v, k);
	}
}
int query(int k)
{
	tot = 0, getdeep(k, 0);
	sort(d + 1, d + 1 + tot);
	int i = 1, j = tot, sum = 0;
	while (i < j)
	{
		if (d[i] + d[j] <= m) sum += (j - i), i++;
		else j--;
	}
	return sum;
}
void dfs(int k)
{
	vis[k] = 1, deep[k] = 0, ans += query(k);
	for (int i = head[k];i != -1;i = edge[i].next)
	{
		int v = edge[i].v;
		if (vis[v]) continue;
		deep[v] = edge[i].len, ans -= query(v);
		sn = son[v], root = 0;
		getroot(v, 0), dfs(root);
	}
}
int main()
{
	int i, j, k, sum, u, v, w;
	while (scanf("%d%d", &n, &m), n||m)
	{
		memset(head, -1, sizeof(head));
		memset(vis, 0, sizeof(vis));
		for (i = 1;i < n;i++)
		{
			scanf("%d%d%d", &u, &v, &w);
			add(u, v, w);
		}
		sn = n, root = 0;
		s[0] = 10000005, getroot(1, 0);
		ans = 0, dfs(root);
		printf("%d\n", ans);
	}
	return 0;
}