poj 1463 Strategic game

原题：
Strategic game
Time Limit: 2000MS Memory Limit: 10000K
Total Submissions: 13192 Accepted: 5971

Description
Bob enjoys playing computer games, especially strategic games, but sometimes he cannot find the solution fast enough and then he is very sad. Now he has the following problem. He must defend a medieval city, the roads of which form a tree. He has to put the minimum number of soldiers on the nodes so that they can observe all the edges. Can you help him?

Your program should find the minimum number of soldiers that Bob has to put for a given tree.
Input
The input contains several data sets in text format. Each data set represents a tree with the following description:

the number of nodes
the description of each node in the following format
node_identifier:(number_of_roads) node_identifier1 node_identifier2 ... node_identifiernumber_of_roads
or
node_identifier:(0)

The node identifiers are integer numbers between 0 and n-1, for n nodes (0 < n <= 1500);the number_of_roads in each line of input will no more than 10. Every edge appears only once in the input data.

Output
The output should be printed on the standard output. For each given input data set, print one integer number in a single line that gives the result (the minimum number of soldiers). An example is given in the following:

Sample Input

4
0:(1) 1
1:(2) 2 3
2:(0)
3:(0)
5
3:(3) 1 4 2
1:(1) 0
2:(0)
0:(0)
4:(0)

Sample Output

1
2

Source
Southeastern Europe 2000

中文：

给你一棵树，让你再树的节点上放上哨兵，每个哨兵可以看管该节点所连接的边，问你最少放多少哨兵可以看管整个树。

代码：

//#include<bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include <limits>
#include <cmath>
#include <cstdio>
using namespace std;
const int maxn = 1505;
const int inf = 9999999;
typedef pair<int,int> edge;
int f1[maxn], f2[maxn]; // f1 放 f2 不放
int n;
vector<int> G[maxn];
bool child[maxn];

void dfs(int cur, int pre) {
    for (int i=0;i<G[cur].size();i++) {
        if (cur == pre) {
            continue;
        }
        dfs(G[cur][i], cur);
        f2[cur] += f1[G[cur][i]];
        f1[cur] += min(f1[G[cur][i]], f2[G[cur][i]]);
    }
}

int main()
{
    // ios::sync_with_stdio(false);
    while (~scanf("%d", &n)) {
        for (int i=0;i<maxn;i++) {
            G[i].clear();
            f1[i] = 1;
        }
        memset(child, false, sizeof(child));
        memset(f2, 0 ,sizeof(f2));
        for (int i = 1; i<=n; i++) {
            int node, chs ,ch;
            scanf("%d:(%d)",&node,&chs);

            for (int j=0;j<chs;j++) {
                scanf("%d", &ch);
                child[ch] = 1;
                G[node].push_back(ch);
                //G[ch].push_back(node);
            }
        }
        int root = 0;
        for (int i=0;i<n;i++) {
            if (!child[i]) {
                root = i;
                break;
            }
        }
        dfs(root, -1);
        cout << min(f1[root], f2[root]) << endl;

    }
    return 0;
}



/*
12
0:(3) 1 2 3
1:(2) 4 5
2:(1) 6
3:(1) 11
4:(2) 7 8
5:(0)
6:(2) 9 10
7:(0)
8:(0)
9:(0)
10:(0)
11:(0)

4
0:(1) 1
1:(2) 2 3
2:(0)
3:(0)
5
3:(3) 1 4 2
1:(1) 0
2:(0)
0:(0)
4:(0)


4
0:(1) 1
1:(1) 2
2:(1) 3
3:(0)

3
0:(1) 1
1:(1) 2
2:(0)

4
0:(3) 1 2 3
1:(0)
2:(0)
3:(0)


5
0:(2) 1 4
1:(2) 2 3
4:(0)
2:(0)
3:(0)

1
0:(0)


*/

解答：

！！！注意，仔细读题，计算的是每个节点看管的边，不是节点！别被数据坑了！！！

设$dp[i][0]$表示节点i不放置哨兵时，以i为根节点的子树所得到覆盖的最少哨兵数量，$dp[i][1]$表示节点i放置哨兵时，以i为根几点的子树所得到的覆盖的最少哨兵数量。

那么
如果节点i不放置哨兵，那么其子节点必须放置哨兵，有：
$dp[i][0] += $dp[child[i]][1]$
如果节点i放置哨兵，那么其子节点可以放置，也可以不放置，找最小的：
$dp[i][1]+=min(dp[child[i]][0],dp[child[i]][1])$

这题里面数据有个比较迷惑，如果不仔细读题，那么会被带到坑里，这个坑就是每个节点最多有10个子节点。
再结合粗略的题意，要计算最小覆盖，很容易想成时每个节点放上哨兵，每个哨兵可以看管其相邻的节点。再加上每个节点最多只有10个节点，容易联想到状态压缩。可能会得到如下的状态转移方程：

设置$dp[i][2][S]$ 其中S为节点i所有叶子节点的状态压缩表示
$dp[i][0][S]$表示当前节点i不放置哨兵时，其子节点的放置状态为S时的最少覆盖。
此时，其子节点同样可以选择放置或者不放置，因为子节点有可能被子节点的字节点放置后所覆盖。

$dp[i][1][S]$表示当前节点i放置哨兵时，其子节点放置状态为S时的最少覆盖。
如果节点i放置，那么子节点同样可以选择放置和不放置，寻找其最小值。