UVA 1292-Strategic game（树形DP）

题目大意：给出一棵树，在某个选择某个结点可以覆盖和它相连的所有边，问最少选多少个结点所有边都被覆盖。

首先将无根树转化为有根树，0为根。

用d[i][0]表示不选择结点i时覆盖以结点i为根的子树最少要多少个结点，用d[i][1]表示选择结点i时覆盖以结点i为根的子树最少要多少个结点。若结点i不选，为了和覆盖所有和结点i相连的结点，则每个儿子都必须选，若结点i选，则每个儿子选择较小的那个值。按DFS顺序递推。

状态转移方程：

d[i][0]=sum { d[u][1] }（u是i的儿子）

d[i][1]=sum { min { d[u][0],d[u][1] } }+1（u是i的儿子）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<vector>
using namespace std;
int a[30];
int d[1510][2];
char e[1510];
int par[1510];
vector<int> G[1510];
void dfs(int u);
void rootedtree(int u,int fa);
int main(void)
{
	int i,j,u,n,sump,top,lo;
	while(scanf("%d",&n)==1)
	{
		for(i=0;i<n;i++)
		{
			G[i].clear();
		}
		for(i=1;i<=n;i++)
		{
			scanf("%s",e);
			lo=strlen(e);
			j=top=0;
			while(j<lo)
			{
				if((e[j]>='0')&&(e[j]<='9'))
				{
					sump=0;
					while((e[j]>='0')&&(e[j]<='9'))
					{
						sump=sump*10+e[j]-'0';
						j++;
					}
					top++;
					a[top]=sump;
				}
				else
				{
					j++;
				}
			}
			for(j=1;j<=a[2];j++)
			{
				scanf("%d",&u);
				G[a[1]].push_back(u);
				G[u].push_back(a[1]);
			}
		}
		rootedtree(0,-1);
		for(i=0;i<n;i++)
		{
			G[i].clear();
		}
		for(i=1;i<n;i++)
		{
			G[par[i]].push_back(i);
		}
		dfs(0);
		printf("%d\n",d[0][0]>d[0][1]?d[0][1]:d[0][0]);
	}
	return 0;
}
void dfs(int u)
{
	int i,p,minp,sump;
	p=G[u].size();
	if(p==0)
	{
		d[u][0]=0;
		d[u][1]=1;
	}
	else
	{
		for(i=0;i<p;i++)
		{
			dfs(G[u][i]);
		}
		sump=minp=0;
		for(i=0;i<p;i++)
		{
			minp=minp+(d[G[u][i]][0]>d[G[u][i]][1]?d[G[u][i]][1]:d[G[u][i]][0]);
			sump=sump+d[G[u][i]][1];
		}
		d[u][0]=sump;
		d[u][1]=minp+1;
	}
}
void rootedtree(int u,int fa)
{
	int i,v,p;
	p=G[u].size();
	for(i=0;i<p;i++)
	{
		v=G[u][i];
		if(v!=fa)
		{
			par[v]=u;
			rootedtree(v,u);
		}
	}
}