poj 3659 树形dp 最小支配集

树形dp 3连发 支配集和覆盖集有不同的定义，覆盖集一定是支配集，但是支配集不一定是覆盖集，覆盖集是每一条边必须有一个点被选择。

        但是支配集只要所有点 1包含在集合内 2 和他相连点在集合内。

比如  1->2->3->4->5->6 覆盖就最小为3 但是支配集为2（选取2 和5 就可以了）

3个状态 dp[i][0] 表示不选i时候最小值

               dp[i][1] 表示选了i时候最小值

               dp[i][2] 表示不选i但是i有至少一个儿子支配

dp[fa][1]=min(dp[son][0],dp[son][1],dp[son][2])+1;

dp[fa][0]=min(dp[son][1],dp[son][2]);

dp[fa][2]=min(dp[son][1],dp[son][2])+max(min(dp[son][1]-dp[son][2],0);(选其一个最优的儿子然后变成1)；

#include<cstdio>
#include<cstring>
#include<iostream>
#define M 20000
#define inf 0x3f3f3f3f
using namespace std;
struct G{
    int head[M],en;
    struct E{
        int u,v,next;
    }e[M<<2];
    void init(){
        memset(head,-1,sizeof(head));en=0;
    }
    void add(int u,int v){
        e[en].u=u;e[en].v=v;e[en].next=head[u];head[u]=en++;
    }
}g1;
int dp[M][3];
void dfs(int u,int fa){
    dp[u][0]=0;
    dp[u][1]=1;
    dp[u][2]=0;
    int tmin=inf;
    int flag=0;
    for(int i=g1.head[u];i!=-1;i=g1.e[i].next){
        int v=g1.e[i].v;
        if(v==fa) continue;
        flag=1;
        dfs(v,u);
        dp[u][0]+=min(dp[v][1],dp[v][2]);
        dp[u][1]+=min(min(dp[v][0],dp[v][1]),dp[v][2]);
        dp[u][2]+=min(dp[v][1],dp[v][2]);
        if(dp[v][1]-dp[v][2]<tmin){
            tmin=dp[v][1]-dp[v][2];
        }
    }
    if(tmin>0) dp[u][2]+=tmin;
}
int main(){
    int n;while(~scanf("%d",&n)){
        g1.init();
        for(int i=0;i<n-1;i++){
            int u,v;scanf("%d%d",&u,&v);
            g1.add(u,v);
            g1.add(v,u);
        }
        dfs(1,-1);
        int ans=min(dp[1][2],dp[1][1]);
        printf("%d\n",ans);
    }
    return 0;
}
/*
6
1 2
1 3
1 4
1 5
1 6
*/