poj3659 Cell Phone Network（树形dp）

题目链接：poj3659

题意：

— 给你一棵无向树，问你最少用多少个点可以覆盖掉所有其他的点。

（一个点被盖，它自己和与它相邻的点都算被覆盖）

思路：

— 第一步：确定 状态

— ① dp [i][0] ：选点 i ， 并且以点 i 为根的子树都被 覆盖了。

— ② dp [i][1] ： 不 选点 i ， i 被其儿子覆盖

— ③ dp [i][2] ： 不 选点 i ， i 没有被子 节点 覆盖（被其父亲覆盖）
（这里其实指的是此点的父亲一定要覆盖他  他对孩子的选择可以是dp[to][0],dp[to][1]中的较小值）

— 第二步：确定状态 转移方程

— dp[i][0]=1+Σmin(dp[u][0],dp[u][1],dp[u][2 ]) （u是i的儿子 ）

— dp[i][2]= Σmin(dp[u][0],dp[u][1]);

— 对于 dp [i][1] 的讨论稍微复杂一点 —— 他的所有儿子里面必须有一个取 dp [u][1]

— 那么： if(i 没有子节点 ) dp [i][1]=INF

— else dp [i][1]= Σ min( dp [u][0], dp [u][1])+ inc

— 其中对于 inc 有：

— if( 上面式子中的 Σ min( dp [u][0], dp [u][1]) 中包含某个 dp [u][0]) inc =0;

— else inc =min( dp [u][0]- dp [u][1]) 。

这里需要注意的是最后的输出：printf("%d\n",min(dp[1][0],min(dp[1][1],dp[1][2]+1)));

#include<iostream>
#include<iostream>
#include<cstring>
#include<string.h>
#include<algorithm>
#include<cstdio>
#include<cmath>
using namespace std;
#define maxn 10100
#define inf 0x3f3f3f3f
int n,m;
int dp[maxn][3];
/*
①dp[i][0]：选点i，并且以点i为根的子树都被覆盖了。
②dp[i][1]：不选点i，i被其儿子覆盖
③dp[i][2]：不选点i，i没有被子节点覆盖（被其父亲覆盖
*/
struct node
{
	int to,next;
}edge[maxn*2];
int head[maxn];
bool vis[maxn];
int cnt;
int min(int a,int b){
    return a<b?a:b;
}
void dfs(int u)
{
	vis[u]=1;
	dp[u][0]=1;
	dp[u][1]=0;
	dp[u][2]=0;
	int flag=0;
	int mine=inf;
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int to=edge[i].to;
		if(vis[to])continue;
		dfs(to);
		dp[u][0]+=min(dp[to][0],min(dp[to][1],dp[to][2]));
        dp[u][2]+=min(dp[to][0],dp[to][1]);
		if(dp[to][0]<=dp[to][1])
		{
			dp[u][1]+=dp[to][0];
			flag=1;
		}
		else
		{
			dp[u][1]+=dp[to][1];
			mine=min(mine,dp[to][0]-dp[to][1]);
		}
	}
	if(!flag)
	{
		dp[u][1]+=mine;
	}
}
int main()
{
	while(~scanf("%d",&n))
	{

		memset(head,-1,sizeof head);
		memset(dp,0,sizeof dp);
		memset(vis,0,sizeof vis);
		int a,b,c;
		cnt=0;
		for(int i=1;i<n;i++)
		{
			scanf("%d%d",&a,&b);
			edge[cnt].to=b;
			edge[cnt].next=head[a];
			head[a]=cnt;
			cnt++;
			edge[cnt].to=a;
			edge[cnt].next=head[b];
			head[b]=cnt;
			cnt++;
		}

		dfs(1);
		printf("%d\n",min(dp[1][0],min(dp[1][1],dp[1][2]+1)));
	}
	return 0;
}