Strategic Game（HDU-1054）

---

1 题意

  在一颗树的节点上驻守士兵，每个士兵能看守所有的邻接边。问：要看守这棵树的所有的边，至少要多少个士兵。
  链接：link

---

2 思路

2.1 动态规划

  状态：
  1. dp[u][0]表示如果u节点不驻守士兵，以u为根节点的子树至少需要驻守多少士兵。
  2. dp[u][1]表示如果u节点驻守士兵，以u为根节点的子树至少需要驻守多少士兵。

  状态转移：
$$\{\begin{array}{l}dp[u][0]=\Sigma (dp[v][1])\\ dp[u][1]=1+\Sigma (min(dp[v][0],dp[v][1]))\end{array}$$

  1. 第一个式子表示如果根节点不驻兵，那么子树的根结点必须驻兵。
  2. 第二个式子表示如果根节点驻兵，那么子树的根节点可以驻兵，也可以不驻兵，此外还要加上根节点驻守的一个士兵。

2.1.1 时间复杂度分析

  每个节点只需要遍历一次，所以时间复杂度是$\mathcal{O}(n)$。

2.1.2 实现

  这里，图使用链式前向星存储，具体参考：link。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int N=1500+10;
int n,dp[N][2];
struct AdjacencyList{
    static const int N=1500+10;
    int head[N],to[N<<1],nxt[N<<1],cnt;
    void init(){
        memset(head,0,sizeof(head));
        cnt=0;
    }
    void add(int x,int y){
        to[++cnt]=y;
        nxt[cnt]=head[x];
        head[x]=cnt;
    }
}al;
void DFS(int cur){
    dp[cur][1]=1;dp[cur][0]=0;
    for(int i=al.head[cur];i;i=al.nxt[i]){
        int nxt=al.to[i];DFS(nxt);
        dp[cur][0]+=dp[nxt][1];
        dp[cur][1]+=min(dp[nxt][0],dp[nxt][1]);
    }
}
int main(){
    while(~scanf("%d",&n)){
        int root,fa,num,cld;
        al.init();
        for(int i=0;i<n;i++){
            scanf("%d:(%d)",&fa,&num);
            if(i==0) root=fa;
            for(int j=0;j<num;j++){
                scanf("%d",&cld);
                al.add(fa,cld);
            }
        }
        memset(dp,0,sizeof(dp));
        DFS(root);
        printf("%d\n",min(dp[root][0],dp[root][1]));
    }
    return 0;
}