poj 3689 树形dp

思路： 每个点有三种状态，本身有塔，被子节点的塔覆盖，被父节点的塔覆盖。

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<cstdio>
#include<vector>
#include<string>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define Maxn 10100
#define Maxm 100010
#define LL __int64
#define Abs(x) ((x)>0?(x):(-x))
#define lson(x) (x<<1)
#define rson(x) (x<<1|1)
#define inf 1000000
#define Mod 1000000007
using namespace std;
int dp[Maxn][3],head[Maxn],vi[Maxn],e;
struct Edge{
    int u,v,val,next;
}edge[Maxn*2];
void init()
{
    memset(dp,0,sizeof(dp));
    memset(head,-1,sizeof(head));
    memset(vi,0,sizeof(vi));
    e=0;
}
void add(int u,int v)
{
    edge[e].u=u,edge[e].v=v,edge[e].next=head[u],head[u]=e++;
    edge[e].u=v,edge[e].v=u,edge[e].next=head[v],head[v]=e++;
}
inline int min(int a,int b,int c)
{
    a=a<b?a:b;
    return a<c?a:c;
}
void dfs(int u)
{
    int i,v;
    vi[u]=1;
    dp[u][0]=1;//有信息塔
    dp[u][1]=0;//由前覆盖
    dp[u][2]=0;//由后覆盖
    int sum=0,f=0,min1=inf;
    for(i=head[u];i!=-1;i=edge[i].next){
        v=edge[i].v;
        if(vi[v]) continue;
        dfs(v);
        dp[u][0]+=min(dp[v][0],dp[v][1],dp[v][2]);
        dp[u][2]+=min(dp[v][1],dp[v][0]);
        if(dp[v][0]<=dp[v][1]){
            sum+=dp[v][0];
            f=1;
        }
        else{
            if(dp[v][0]-dp[v][1]<min1){
                min1=dp[v][0]-dp[v][1];
            }
            sum+=dp[v][1];
        }
    }
    if(f) dp[u][1]=sum;
    else dp[u][1]=sum+min1;
}
int main()
{
    int n,i,j,u,v;
    while(scanf("%d",&n)!=EOF){
        init();
        for(i=1;i<n;i++){
            scanf("%d%d",&u,&v);
            add(u,v);
        }
        dfs(1);
        printf("%d\n",min(dp[1][0],dp[1][1]));
    }
    return 0;
}