POJ-3659-最小支配集裸题/树形dp

Cell Phone Network

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 7127		Accepted: 2549

Description

Farmer John has decided to give each of his cows a cell phone in hopes to encourage their social interaction. This, however, requires him to set up cell phone towers on his N (1 ≤ N ≤ 10,000) pastures (conveniently numbered 1..N) so they can all communicate.

Exactly N-1 pairs of pastures are adjacent, and for any two pastures A and B (1 ≤ A ≤ N; 1 ≤ B ≤ N; A ≠ B) there is a sequence of adjacent pastures such that A is the first pasture in the sequence and B is the last. Farmer John can only place cell phone towers in the pastures, and each tower has enough range to provide service to the pasture it is on and all pastures adjacent to the pasture with the cell tower.

Help him determine the minimum number of towers he must install to provide cell phone service to each pasture.

Input

* Line 1: A single integer: N
* Lines 2..N: Each line specifies a pair of adjacent pastures with two space-separated integers: A and B

Output

* Line 1: A single integer indicating the minimum number of towers to install

Sample Input

5
1 3
5 2
4 3
3 5

Sample Output

2

Source

USACO 2008 January Gold

一开始令f[i][0/1]表示属于/不属于支配集的最优解，后来发现这个方程有问题，如果i不属于支配集，他的儿子可能也不属于支配集而是被儿子的儿子所覆盖，这样子就没办法表示了。换句话说状态表示不全。

    　　 　　就是一道模板最小支配集，用树形dp实现，注意不能转移的状态用inf表示；

　f[i][0]表示i属于支配集且i的子树全被覆盖情况下，最小的支配集。

    f[i][1]表示i不属于支配集，i被至少一个子节点所覆盖，且i的子树全被覆盖情况下，最小的支配集。

    f[i][2]表示i不属于支配集，i不被任何一个子节点覆盖，且i的子树全被覆盖情况下，最小的支配集。

   有转移方程 f[i][0]=1+SUM{MIN{f[j][0],f[j][1],f[j][2]} }

　　　　　　 f[i][1]=f[jx][0]+SUM{min(f[j][0],f[j][1]) | j!=jx}

　　　　　　 f[i][2]=sum{f[j][1] }  /// 注意inf的状态不能被转移，f[i][1],至少有一个i的儿子是由f[j][0]转移而来的才ok。

  

　　

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
#define inf 0x3f3f3f3f
int f[10010][3];
vector<int>g[10010];
void dfs(int u,int fa)
{
    f[u][0]=1;
    f[u][2]=0;
    int sum=0,inc=inf;
    bool flag=0;
    for(int i=0;i<g[u].size();++i){
        int v=g[u][i];
        if(v==fa) continue;
        dfs(v,u);
        if(f[v][0]<=f[v][1]){
            sum+=f[v][0];
            flag=1;
        }
        else{
            sum+=f[v][1];
            inc=min(inc,f[v][0]-f[v][1]);
        }
        f[u][0]+=min(f[v][0],min(f[v][1],f[v][2]));
        if(f[v][1]!=inf&&f[u][2]!=inf) f[u][2]+=f[v][1];///inf表示当前节点不会出现此状态
        else f[u][2]=inf;
    }
    if(inc==inf && flag==0) f[u][1]=inf;
    else{
        f[u][1]=sum;
        if(!flag) f[u][1]+=inc;
    }
    if(f[u][1]==0) f[u][1]=inf;
}
int main()
{
    int n,i,j,k,u,v;
    while(cin>>n){
        for(i=1;i<n;++i){
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        dfs(1,0);
        cout<<min(f[1][0],f[1][1])<<endl;
        for(i=1;i<=n;++i) g[i].clear();
    }
    return 0;
}