1578：【例 4】战略游戏(最小点覆盖 树形DP)_1578:【例 4】战略游戏

【题目描述】 Bob 喜欢玩电脑游戏，特别是战略游戏。但是他经常无法找到快速玩过游戏的方法。现在他有个问题
现在他有座古城堡，古城堡的路形成一棵树。他要在这棵树的节点上放置最少数目的士兵，使得这些士兵能够瞭望到所有的路。
注意：某个士兵在一个节点上时，与该节点相连的所有边都将能被瞭望到。 请你编一个程序，给定一棵树，帮 Bob 计算出他最少要放置的士兵数。
【输入】 输入数据表示一棵树，描述如下 第一行一个数 N, 表示树中节点的数目。
第二到第 N+1 行，每行描述每个节点信息，依次为该节点编号 i, 数值 k,
k 表示后面有 k 条边与节点 i 相连，接下来 k 个数，分别是每条边的所连节点编号 n,r, …,k。
对于一个有 N 个节点的树，节点标号在 0 到 N-1 之间，且在输入文件中每条边仅出现一次。 【输出】 输出仅包含一个数，为所求的最少士兵数，

题意

最小点覆盖：在二分图中，求最少的点集，使得每一条边至少都有端点在这个点集中。

思路

1. 定义：
   1. dp [u][0] 表示在节点 u 不放士兵时，覆盖以 u 为根的子树中的所有的边的 最小士兵数量。
   2. dp [u][1] 表示在节点 u 放士兵时，覆盖以 u 为根的子树中的所有的边的 最小士兵数量。

状态转移方程：

//初始值：dp[u][0] = 0, dp[u][1] = 1; 

dp[u][0] += dp[vi][1];
dp[u][1] += min(dp[vi][0], dp[vi][1]);
//vi 为u的子节点

1
2
3
4
5
6

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
/* #include <unordered_map> */
#include <bitset>
#include <vector>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define ll long long
#define ull unsigned long long
#define db double
#define Pir pair<int, int>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
#define size() size() * 1LL
#define mod (ll)(10007)
#define Min(a, b, c) min(a, min(b, c))
#define Max(a, b, c) max(a, max(b, c))
using namespace std;

const int mxn = 2e3;
vector<int> e[mxn];
int dp[mxn][2];

void dfs(int u, int p)
{
    dp[u][0] = 0, dp[u][1] = 1; 

    for_(i, 0, e[u].size() - 1)
    {
        int v = e[u][i];
        if(v == p) continue;
        dfs(v, u);        
        dp[u][0] += dp[v][1];
        dp[u][1] += min(dp[v][0], dp[v][1]);
    }
}


int main()
{
    /* fre(); */
    int n; sd(n);
    int u, v, t;
    for_(i, 1, n)
    {
        sc("%d %d", &u, &t);
        for_(i, 1, t)
        {
            sd(v);
            e[u].pb(v);
            e[v].pb(u);
        }
    }

    dfs(0, -1);
    pr("%d\n", min(dp[0][0], dp[0][1]));

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78