poj1463 Strategic game（树形dp）

简单树形dp

树的最小点覆盖

dp[u][0]+=dp[v][1]; u-v 如果u不覆盖则v一定覆盖

dp[u][1]+=min(dp[v][0],dp[v][1]);u-v 如果u覆盖则v可以覆盖或者不覆盖

#include<algorithm>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<iostream>
using namespace std;
const int N=6010;
int dp[N][2],head[N<<1],cnt,n,val[N];
int in[N],ou[N];
struct node
{
    int u,v,w,next;
} ed[N<<2];
void add(int u,int v)
{
    ed[cnt].u=u;
    ed[cnt].v=v;
    //ed[cnt].w=w;
    ed[cnt].next=head[u];
    head[u]=cnt++;
}
void dfs(int u,int fa)
{
    for(int i=head[u]; i!=-1; i=ed[i].next)
    {
        int v=ed[i].v;
        if(v==fa)
            continue;
        dfs(v,u);
        dp[u][0]+=dp[v][1];
        dp[u][1]+=min(dp[v][0],dp[v][1]);
    }
}
int main()
{
    while(~scanf("%d",&n))
    {
        int u,v,a;
        memset(head,-1,sizeof(head));
        cnt=0;
        for(int i=1; i<=n; i++)
        {
            scanf("%d:(%d)",&u,&a);
            while(a--)
            {
                scanf("%d",&v);
                add(u,v);
                add(v,u);
            }
        }
        //memset(dp,0,sizeof(dp));
        for(int i=0; i<=n; i++)
        {
            dp[i][0]=0;
            dp[i][1]=1;
        }
        dfs(0,-1);
        cout<<min(dp[0][1],dp[0][0])<<endl;
    }
    return 0;
}
///