最小支配集

题目链接

http://poj.org/problem?id=3659

详细理论看这里

http://www.tuicool.com/articles/zUfuquf

分析：

模板题目吧，我用dp 做了，过程写了注释

解释一下 dp数组

dp[u][0]代表当前节点为支配集里面的点

dp[u][1]代表当前节点的子节点中有一个为支配集里面的点，所以把当前的点也覆盖了

dp[u][2]代表当前节点的父节点为支配集里面的点，覆盖了当前节点

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
#define maxn 10000+5
struct node
{
    int to;
    int nxt;
};
int head[maxn];
node data[maxn<<1];
int dp[maxn][3];
int vis[maxn];
int N;
int cnt;
void init()
{
    memset(head,-1,sizeof(head));
    memset(dp,0,sizeof(dp));
    memset(vis,0,sizeof(vis));
    cnt = 0;
}
void add(int u,int v)
{
    data[cnt].to = v;
    data[cnt].nxt = head[u];
    head[u] = cnt++;
}

void dfs(int u)
{
    vis[u] = 1;
    dp[u][0] = 1;//自身覆盖
    dp[u][1] = dp[u][2] = 0;//子覆盖 ， 父覆盖
    int flag = 1;//是否有子覆盖
    int mi = 1e9;
    for(int i = head[u] ; i != -1 ; i = data[i].nxt)
    {
        int v = data[i].to;
        if(!vis[v])
        {
            dfs(v);//查询子
            dp[u][0] += min(dp[v][0] , min(dp[v][1],dp[v][2]));//因为自身要覆盖，所以取子节点最小的就行
            dp[u][2] += min(dp[v][0],dp[v][1]);//父覆盖，那么子节点要自身覆盖或被子节点的子覆盖
            if( dp[v][0] <= dp[v][1] )//如果存在子覆盖
            {
                 flag = 0;
                 dp[u][1] += dp[v][0];
            }
            else//不存在
            {
                dp[u][1] += dp[v][1];
                mi = min(mi,dp[v][0] - dp[v][1]);//找出子节点最小的自身覆盖情况
            }
        }
    }
    if( flag )//子节点不存在自身覆盖，那么强制一个自身覆盖
    {
        dp[u][1] += mi;
    }
}

int main()
{
    while(cin >> N)
    {
        init();
        for(int i = 1 ; i < N ; ++i)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            add(a,b);
            add(b,a);
        }
        dfs(1);
        cout << min(dp[1][0],dp[1][1]) << endl;
    }
}