HLG1477战争与守卫【树形dp】

Description

J国和C国爆发了战争，J国派出了很多间谍深入到C国内部，经常在C国的城市之间炸毁道路，阻拦C国的军队，C国为了抓到这些间谍，需要派人在城市进行监视，一个城市只要有一个人监视，那么这个城市的所有的道路也都会被监视到，为了能够尽量多的士兵去前线打仗，监视的士兵要尽可能的少，希望靠你编程求出至少需要多少人能实现对所有城市之间道路的监视。

Input

有多组测试数据

每组测试数据的第一行，一个整数n表示C国城市的数量(编号为0-----n-1) n<=2000

接下来n行：i:(M)表示有M个城市和城市i之间有道路连通，然后是M个整数表示和i连通的城市的编号。

处理到文件结束，输入数据保证是一棵树。

Output

输出一个整数，表示至少需要多少士兵能实现对所有道路的监视。

Sample Input

4

0:(1) 1

1:(2) 2 3

2:(0)

3:(0)

Sample Output

1

Source

Southeastern Europe 2000

分析：这个题跟上一个很像

dp[x][0]表示x为根节点的树不选x点并且把所有的点都覆盖的的最少士兵
dp[x][1]表示x为根节点的树选x点并且把所有的点都覆盖的的最少士兵

dp[x][0] = sum(dp[y][1]) + 1

dp[x][1] = sum(min(dp[y][0], dp[y][1]))

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 2005;
int dp[maxn][2];
int n;
int in[maxn], out[maxn];
struct Node {
    int to, next;
}e[maxn * maxn];
int tot;
int head[maxn];
void add(int u, int v) {
    e[tot].to = v;
    e[tot].next = head[u];
    head[u] = tot++;
}
int boss;

void dfs(int u) {
    if(out[u] == 0) {
        dp[u][0] = 0;
        dp[u][1] = 1;
        return ;
    }
    int sum1 = 0; int sum2 = 0;
    for(int i = head[u]; i; i = e[i].next) {
        int v = e[i].to;
        dfs(v);
        sum1 += dp[v][1];
        sum2 += min(dp[v][0], dp[v][1]);
    }
    dp[u][0] = sum1;
    dp[u][1] = sum2 + 1;
}

int DP() {
    memset(dp, 0, sizeof(dp));
    dfs(boss);
    return min(dp[boss][0], dp[boss][1]);
}

int main() {
    int u, m, v;
    while(EOF != scanf("%d",&n) ) {
        memset(in, 0, sizeof(in));
        memset(out, 0, sizeof(out));
        memset(head, 0, sizeof(head));
        tot = 1;
        for(int i = 1; i <= n; i++) {
            scanf("%d:(%d)", &u, &m);
            for(int j = 1; j <= m; j++) {
                scanf("%d",&v);
                add(u, v);
                out[u]++; in[v]++;
            }
        }
        for(int i = 0; i < n; i++) {
            if(in[i] == 0) {
                boss = i;
                break;
            }
        }
        printf("%d
", DP());
    }
    return 0;
}