POJ 1741 树形dp

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int Maxn = 2E5 + 10;
const int Maxm = 1E5 + 10;
const int INF = 0x3f3f3f3f;
int N, K, first[Maxm], x, y, z, Next[Maxm], v[Maxm], w[Maxm], cnt, res, q[Maxn], fa[Maxn], p[Maxn], del[Maxn], size[Maxn];
void add(int x, int y, int z)
{
	v[cnt] = y, w[cnt] = z, Next[cnt] = first[x], first[x] = cnt++;
}
int findroot(int cur)
{
	int i, j, x, rear = 0, Max, min = INF, root;
	q[rear ++] = cur, fa[cur] = 0;
	for (i = 0; i < rear; i ++)
	{
		x = q[i];
		for (j = first[x]; j != -1; j = Next[j])
			if (!del[v[j]] && v[j] != fa[x])
				q[rear ++] = v[j], fa[v[j]] = x;
	}
	for (i = rear - 1; i >= 0; i --)
	{
		x = q[i];
		size[x] = 1, Max = 0;
		for (j = first[x]; j != -1; j = Next[j])
			if (!del[v[j]] && v[j] != fa[x])
				size[x] += size[v[j]], Max = max(Max, size[v[j]]);
		Max = max(Max, rear - size[x]);
		if (Max < min)
			min = Max, root = x;
	}
	return root;
}
int deal(int s, int t)
{
	int i, rear = t, ans = 0;
	for (i = s; i <= t; i ++)
	{
		while (rear >= s && p[rear] + p[i] > K)
			-- rear;
		ans += rear - s + 1;
	}
	return ans;
}
void renew(int s, int cur, int d)
{
	int i, j, x, rear = 0;
	q[rear ++] = cur, fa[cur] = 0, p[s] = d;
	for (i = 0; i < rear; i ++)
	{
		x = q[i];
		for (j = first[x]; j != -1; j = Next[j])
			if (!del[v[j]] && v[j] != fa[x])
				p[s + rear] = p[s + i] + w[j], q[rear ++] = v[j], fa[v[j]] = x;
	}
	sort(p + s, p + s + rear);
}
int dfs(int s, int cur, int d)
{
	int i, root, n, tot = 1;
	root = findroot(cur);
	del[root] = 1;
	for (i = first[root]; i != -1; i = Next[i])
		if (!del[v[i]])
		{
			n = dfs(s + tot, v[i], w[i]);
			res -= deal(s + tot, s + tot + n - 1);
			tot += n;
		}
	p[s] = 0;
	sort(p + s, p + s + tot);
	res += deal(s, s + tot - 1) - 1;
	del[root] = 0;
	renew(s, cur, d);
	return tot;
}
int main(int argc, char const *argv[])
{
	while (~scanf("%d%d", &N, &K) && N + K)
	{
		cnt = 0; res = 0;
		memset(first, -1, sizeof(first));
		for (int i = 1; i < N; i++)
			scanf("%d%d%d", &x, &y, &z), add(x, y, z), add(y, x, z);
		dfs(0, 1, 0);
		printf("%d\n", res >> 1);
	}
	return 0;
}

 恩，楼教主的八题之一，需要优化的树形dp，具体思路有漆子超的《分治算法在树的路径问题中的应用》这篇论文。

题解思路来自：http://blog.sina.com.cn/s/blog_6d5aa19a0100o73m.html

//__________________________________________________________

对于一棵有根树， 树中满足要求的一个数对所对应的一条路径，必然是以下两种情况之一：
1、经过根节点
2、不经过根节点，也就是说在根节点的一棵子树中
对于情况2，可以递归求解，下面主要来考虑情况1。

设X为满足i<j且Depth[i]+Depth[j]<=K的数对(i,j)的个数
设Y为满足i<j，Depth[i]+Depth[j]<=K且Belong[i]=Belong[j]数对(i,j)的个数
那么我们要统计的量便等于X-Y


求X、Y的过程均可以转化为以下问题：
已知A[1],A[2],...A[m]，求满足i<j且A[i]+A[j]<=K的数对(i,j)的个数


对于这个问题，我们先将A从小到大排序。
设B[i]表示满足A[i]+A[p]<=K的最大的p(若不存在则为0)。我们的任务便转化为求出A所对应的B数组。那么，若B[i]>i，那么i对答案的贡献为B[i]-i。
显然，随着i的增大，B[i]的值是不会增大的。利用这个性质，我们可以在线性的时间内求出B数组，从而得到答案。


综上，设递归最大层数为L，因为每一层的时间复杂度均为“瓶颈”——排序的时间复杂度O(NlogN)，所以总的时间复杂度为O(L*NlogN)

//_________________________________________________________________________________________________________