树形dp（最小支配集）

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

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

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

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

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

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