P2016 战略游戏-树上DP之最小点集覆盖

题目链接战略游戏 - 洛谷

题目背景

Bob 喜欢玩电脑游戏，特别是战略游戏。但是他经常无法找到快速玩过游戏的办法。现在他有个问题。

题目描述

他要建立一个古城堡，城堡中的路形成一棵无根树。他要在这棵树的结点上放置最少数目的士兵，使得这些士兵能了望到所有的路。

注意，某个士兵在一个结点上时，与该结点相连的所有边将都可以被了望到。

请你编一程序，给定一树，帮 Bob 计算出他需要放置最少的士兵。

输入格式

第一行一个整数 nn，表示树中结点的数目。

第二行至第 n+1n+1 行，每行描述每个结点信息，依次为：一个整数 ii，代表该结点标号，一个自然数 kk，代表后面有 kk 条无向边与结点 ii 相连。接下来 kk 个整数，分别是每条边的另一个结点标号 r_1,r_2,\cdots,r_kr1​,r2​,⋯,rk​，表示 ii 与这些点间各有一条无向边相连。

对于一个nn 个结点的树，结点标号在 00 到 n-1n−1 之间，在输入数据中每条边只出现一次。保证输入是一棵树。

输出格式

输出文件仅包含一个整数，为所求的最少的士兵数目。

输入输出样例

输入 #1复制

4
0 1 1
1 2 2 3
2 0
3 0

输出 #1复制

1

说明/提示

数据规模与约定

对于全部的测试点，保证 1 \leq n \leq 15001≤n≤1500。

---------------------------------------------------------------------------------------------------------------------------------

树上最小点集覆盖的模板题目，设置dp[i][0]与dp[i][1]分别表示i节点是否放置人时，其子树包含其本身需要的最小人数。如果本节点不放置人，那么其儿子节点必须放置，dp[now][0]+=dp[j][1];

如果放置，那么其儿子节点的放置就无所谓了，选取最小的一种情况dp[now][1]+=min(dp[j][1],dp[j][0]);

画模型会比较明确

                                                                       1

                                                    2                                   3

                                            4              5                   6             7

                                       8        9   10      11        12    13   14    15

最优情况是四个点

最底层点递归时情况一样

dp[i][0]=0  dp[i][1]

倒数第二层   dp[i][0]+=dp[儿子][1]=2

                   dp[i][1]=1 dp[i][1]+=min(dp[son][0],dp[son][1])=1 

第二层

            dp[i][0]+=dp[son][1]=2

            dp[i][1]+=min(dp[son][0],dp[son][1])=1+2=3

以此类推即可

#include <iostream>
# include<cstring>
using namespace std;
typedef struct
{
    int b,e;

}xinxi;
xinxi s[100000];
int len=0;
int f[100000];
int nex[100000];

void add(int x,int y)
{
    s[len].b=x;
    s[len].e=y;

    nex[len]=f[x];
    f[x]=len;
    len++;

}

int dp[1510][2];

void dfs(int now,int father)
{
    dp[now][1]=1;

    int x=f[now];

    while(x!=-1)
    {
        int j=s[x].e;

        if(j==father)
        {
            x=nex[x];
            continue;

        }

        dfs(j,now);
        dp[now][0]+=dp[j][1];

        dp[now][1]+=min(dp[j][1],dp[j][0]);
        x=nex[x];
    }
}
int main()
{
    int n;
    cin>>n;
    memset(f,-1,sizeof(f));


    for(int i=0;i<n;i++)
    {
        int t;


        int y;
        cin>>y;
cin>>t;
        while(t--)
        {
            int x;

            cin>>x;

            add(x,y);

            add(y,x);
        }
    }


    dfs(0,-9);

    cout<<min(dp[0][0],dp[0][1]);

    return 0;
}