树形dp（最小支配集）

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

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<vector>
using namespace std;
const int M=1e4+4;
const int inf=0x3f3f3f3f;
vector<int>e[M];
int dp[M][3];
void dfs(int u ,int f){
    dp[u][0]=1;
    int minn=inf;
    int flag=1;
    for(int i=0;i<e[u].size();i++){
        int v=e[u][i];
        if(v==f)
            continue;
        dfs(v,u);
        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{
            minn=min(minn,dp[v][0]-dp[v][1]);
            dp[u][1]+=dp[v][1];
        }
    }
    if(flag)
        dp[u][1]+=minn;
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        e[u].push_back(v);
        e[v].push_back(u);
    }
    dfs(1,-1);
    printf("%d",min(dp[1][0],dp[1][1]));
    return 0;
}

解题：可以用动态规划，也可以用最小支配集。

一、现在先说用动态规划的思路：

         根据题意知道每个节点有三种状态：

              1、点i建塔，i的所有孩子都覆盖，用dp[i][0]表示；

              2、点i不建塔，i和i的所有孩子都覆盖，用dp[i][1]表示；

              3、点i不建塔，i不覆盖，i的所有孩子都覆盖，用dp[i][2]表示；

         如果这样不好理解那么这样理解可能容易一点（参考别人的）：覆盖i，要么是父节点覆盖，要么是自己，要么是孩子，所以三种状态（和上面的对应）：             

              1、点i自己覆盖自己，i的所有孩子都覆盖，用dp[i][0]表示；

              2、点i被自己的孩子覆盖，i和i的所有孩子都覆盖，用dp[i][1]表示；

              3、点i被父节点覆盖，i的所有孩子都覆盖，用dp[i][2]表示；

         那么动态转移方程就是（v是i的孩子）：

              dp[i][0]+=min(dp[v][0],dp[v][1],dp[v][2]);

              dp[i][2]+=min(dp[v][0],dp[v][1]);

              对于dp[i][1],要考虑全面，也就是说：必须要有一个孩子建塔，才能保证i被覆盖（Min=sum(min(dp[v][0]-dp[i][1]))，也就是当所有孩子的dp[v][0]>dp[v][i]时，Min表示他们差值最小的那个差值）。

              所以方程是dp[i][1]+=min(dp[v][0],dp[1])（至少存在一个孩子的dp[v][0]<=dp[v][1]，否则要dp[i][1]+=Min）；

原文：https://blog.csdn.net/jiang199235jiangjj/article/details/7878473