poj 3659 Cell Phone Network 树型DP

题目：poj 3659 Cell Phone Network

题意：农夫给他的每个牛发另一个手机（有点扯），现在要在农场建设信号塔以便所有的牛可以相互联系，每个信号塔可以供和他相连的农场使用，所有农场形成一颗树，问要达到要求最少建塔的数量。也就是给一颗树，每个节点可以覆盖和他相连的所有节点，现在问你用最少的点把所有的点覆盖完。

这个题目和poj1463有点相似，poj1463是用点覆盖边，相对简单很多（poj1463解题报告）；

解题：可以用动态规划，也可以用最小支配集。

一、现在先说用动态规划的思路：

         根据题意知道每个节点有三种状态：

              1、点i建塔，i的所有孩子都覆盖，用dp[i][0]表示；

              2、点i不建塔，i和i的所有孩子都覆盖，用dp[i][1]表示；

              3、点i不建塔，i不覆盖，i的所有孩子都覆盖，用dp[i][2]表示；

         如果这样不好理解那么这样理解可能容易一点（参考别人的）：覆盖i，要么是父节点覆盖，要么是自己，要么是孩子，所以三种状态（和上面的对应）：             

              1、点i自己覆盖自己，i的所有孩子都覆盖，用dp[i][0]表示；

              2、点i被自己的孩子覆盖，i和i的所有孩子都覆盖，用dp[i][1]表示；

              3、点i被父节点覆盖，i的所有孩子都覆盖，用dp[i][2]表示；

         那么动态转移方程就是（v是i的孩子）：

              dp[i][0]+=min(dp[v][0],dp[v][1],dp[v][2]);

              dp[i][2]+=min(dp[v][0],dp[v][1]);

              对于dp[i][1],要考虑全面，也就是说：必须要有一个孩子建塔，才能保证i被覆盖（Min=sum(min(dp[v][0]-dp[i][1]))，也就是当所有孩子的dp[v][0]>dp[v][i]时，Min表示他们差值最小的那个差值）。

              所以方程是dp[i][1]+=min(dp[v][0],dp[1])（至少存在一个孩子的dp[v][0]<=dp[v][1]，否则要dp[i][1]+=Min）；

以上思路感觉其他博客讲的挺好的，所以直接复制粘贴了

不过做题时脑子瓦特了，遇到了一个问题就是：觉得当计算dp[i][2]时，如果i的子节点v是最后的结点那它自己不是没有覆盖了么，于是硬性把这种情况时+1了，结果感觉很合理，但是oj上一直WA。今天心累，不想仔细探究原因了，这个问题日后再想吧

正确的dfs代码：

void dfs(int rot,int pre)
{
	int v,f,t,q;
	t=1<<30;
	f=1;
	dp[rot][0]=1;dp[rot][1]=dp[rot][2]=0;
	for(int i=head[rot];i!=-1;i=s[i].next)
	{
		v=s[i].v;
		if(v!=pre)
		{
			dfs(v,rot);
			dp[rot][0]+=min(dp[v][0],min(dp[v][1],dp[v][2]));
			dp[rot][2]+=min(dp[v][0],dp[v][1]);
			dp[rot][1]+=min(dp[v][0],dp[v][1]);
			t=min(t,dp[v][0]-dp[v][1]);
		}
	}
	if(t>0)
	dp[rot][1]+=t;	
}

错误的dfs代码：

int dfs(int rot,int pre)
{
	int v,f,t,q;
	t=1<<30;
	f=1;
	dp[rot][0]=1;dp[rot][1]=dp[rot][2]=0;
	for(int i=head[rot];i!=-1;i=s[i].next)
	{
		v=s[i].v;
		if(v!=pre)
		{
			f=0;
			q=dfs(v,rot);
			dp[rot][0]+=min(dp[v][0],min(dp[v][1],dp[v][2]));
			if(!q)
			dp[rot][2]+=min(dp[v][0],dp[v][1]);
			else
			dp[rot][2]+=1;
			dp[rot][1]+=min(dp[v][0],dp[v][1]);
			t=min(t,dp[v][0]-dp[v][1]);
		}
	}
	if(f)
	{
		dp[rot][0]=1;
		dp[rot][1]=dp[rot][2]=0;
		return 1;
	}
	if(t>0)
	dp[rot][1]+=t;	
	return 0;
}

正确完整代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
int cnt;
struct node
{
	int v,next;
}s[20009];
int head[10009];
int dp[10009][3];
void addedge(int u,int v)
{
	s[cnt].v=v;
	s[cnt].next=head[u];
	head[u]=cnt++;
	s[cnt].v=u;
	s[cnt].next=head[v];
	head[v]=cnt++;
}
void dfs(int rot,int pre)
{
	int v,f,t,q;
	t=1<<30;
	f=1;
	dp[rot][0]=1;dp[rot][1]=dp[rot][2]=0;
	for(int i=head[rot];i!=-1;i=s[i].next)
	{
		v=s[i].v;
		if(v!=pre)
		{
			dfs(v,rot);
			dp[rot][0]+=min(dp[v][0],min(dp[v][1],dp[v][2]));
			dp[rot][2]+=min(dp[v][0],dp[v][1]);
			dp[rot][1]+=min(dp[v][0],dp[v][1]);
			t=min(t,dp[v][0]-dp[v][1]);
		}
	}
	if(t>0)
	dp[rot][1]+=t;	
}
int main()
{
	int n,u,v;
	while(scanf("%d",&n)!=EOF)
	{
		memset(head,-1,sizeof(head));
		cnt=0;
		for(int i=0;i<n-1;i++)
		{
			scanf("%d%d",&u,&v);
			addedge(u,v);
		}	
		int ans;
		memset(dp,0,sizeof(dp));
		dfs(1,-1);
		ans=min(dp[1][0],dp[1][1]);
		printf("%d\n",ans);
	}
	return 0;
}