POJ2114【树分治】

题意：

给出一棵树，边权值。问存不存在这样一条路径（u，v），u到v路径上的边权值得和恰好等于K。

思路：

这道题不可避免的要考虑所有路径（u，v）的情况（如果大牛们有什么更好的想法求告知，orz）。我们这样考虑： 对于一个节点u，我们统计所有经过u节点的路径是否满足题意，每扫描过一个点，然后将其剔除。如果我们用最暴力的扫描方式，每次扫完一点然后接着扫与其相邻的点，递归的深度则取决于树的形状，对于一棵平衡二叉树，递归深度为O（LogN），但对于一棵退化的树（链），则为O（N）。所以，如果暴力去借，链状的树O（N^2）肯定会爆炸，但如果是平衡树则O（NLogN）。

为了避免被链状的退化树被爆掉的情况，我们引入一个定义：

树的重心：使得最大子树最小的结点。

这样就可以尽量的均分成两棵子树,吧递归深度控制在NlogN。

我们标记最大子树的大小用一个dfs，寻找重心用一个dfs，两个dfs, 然后分治的时候一个dfs，三个dfs完事。

/********************************************************************************************************************************

然后对于这道题，类似于POJ1741：对于每一次分治，我们统计经过点u的所有路径的和恰好等于K的个数。

然后我们继续考虑，对于这样的点u路径的组合无非就是这样两种情况：

1.目标 路径跨过点u分布在两个子树中。

2. 目标路径由一棵子树的路径组成。

很显然，我们统计的是1.种情况。那么我们用一种O（N）的方法求出所有的目标路径，然后减去u的子树单独组成的路径，就是答案的个数。如果答案个数非零，则就是存在，否则就是不存在。（跟POJ1741一样一样的）。

********************************************************************************************************************************/

所以，总的复杂度是O(F(N)*log(N)), F(N)是你所处理子问题的方法的复杂度。

不管怎么说，树分治只是一种辅助手段，F(N)的处理才是考点。

另： 推荐HDU4812，HDU5469,这道题的升级版，可以考虑那边的F(N)是如何处理。

orz。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int INF = 1 << 30;
const int size_max = 10010;
int dis[size_max];
int head[size_max];
int maxe[size_max];
int size[size_max];
bool vis[size_max];
long long ans = 0;
int N, k, E_cnt, root, D_cnt;
struct Edge
{
	int u, v, w;
	int next;
	Edge() { }
	Edge(int u, int v, int w):u(u),v(v),w(w) { }
}edges[size_max << 3];

void init()
{
	ans = 0;
	E_cnt = 0;
	memset(vis,0,sizeof(vis));
	memset(maxe,0,sizeof(maxe));
	memset(head,-1,sizeof(head));
}

void addEdge(int u, int v, int w)
{
	edges[E_cnt] = Edge(u, v, w);
	edges[E_cnt].next = head[u];
	head[u] = E_cnt ++;

	edges[E_cnt] = Edge(v, u, w);
	edges[E_cnt].next = head[v];
	head[v] = E_cnt ++;
}

void dfs_size(int u, int f)
{
	size[u] = 1;
	maxe[u] = 0;
	for(int i = head[u]; i + 1; i = edges[i].next)
	{
		int v = edges[i].v;
		if(!vis[v] && v != f)
        {
            dfs_size(v, u);
            size[u] += size[v];
            maxe[u] = max(size[v] , maxe[u]);
        }
	}
}

int min_node /* = INF */;
void dfs_root(int u, int f, int r)
{
	maxe[u] = max(maxe[u], size[r] - size[u]);
	if(min_node > maxe[u])
		min_node = maxe[u], root = u;
	for(int i = head[u]; i + 1; i = edges[i].next)
	{
		int v = edges[i].v;
		if(!vis[v] && v != f)
			dfs_root(v, u, r);
	}
}

void dfs_dis(int u, int f, int d)
{
	dis[D_cnt ++] = d;
	for(int i = head[u]; i + 1; i = edges[i].next)
	{
		int v = edges[i].v;
		if(!vis[v] && v != f)
			dfs_dis(v, u, d + edges[i].w);
	}
}

long long cal(int u, int d)
{
	D_cnt = 0;
	long long ret = 0;
	dfs_dis(u, 0, d);
	sort(dis, dis + D_cnt);
	int l = 0, r = D_cnt - 1;
	while(l < r)
	{
		if(dis[l] + dis[r] < k) l ++;
		else if(dis[l] + dis[r] > k) r --;
		else if(l == r) ret ++, l ++;
		else
		{
			int i = l, j = r;
			if(dis[i] != dis[j])
            {
                while(dis[i] == dis[l]) i ++;
                while(dis[j] == dis[r]) j --;
                ret += (i - l) * (r - j);
            }
			else
            {
                while(dis[i] == dis[l]) i ++;
                ret += i * (i - 1) / 2;
			}
			l = i, r = j;
		}
	}
	return ret;
}
void dfs_divide_tree(int u)
{
	min_node = N;
	dfs_size(u, 0);
	dfs_root(u, 0, u);
	ans += cal(root, 0);
	vis[root] = true;
	for(int i = head[root]; i + 1; i = edges[i].next)
	{
		int v = edges[i].v;
		if(!vis[v])
        {
            ans -= cal(v, edges[i].w);
			dfs_divide_tree(v);
        }
	}
}

int main(int argc, char const *argv[])
{
	while(scanf("%d",&N) && N)
	{
		init();
		int u, v, w;
		for(int i = 1; i <= N; i ++)
		{
			while(scanf("%d",&u) && u)
			{
				scanf("%d",&w);
				addEdge(i, u, w);
			}
		}
		while(scanf("%d",&k) && k)
		{
			ans = 0;
			memset(vis,0,sizeof(vis));
			dfs_divide_tree(1);
			if(ans == 0)
				puts("NAY");
			else
				puts("AYE");
		}
		printf(".\n");
	}
	return 0;
}