【题解】保安站岗[P2458]皇宫看守[LOJ10157][SDOI2006]

【题解】保安站岗[P2458]皇宫看守[LOJ10157][SDOI2006]

传送门：皇宫看守\([LOJ10157]\) 保安站岗 \([P2458]\) \([SDOI2006]\)

【题目描述】

给你一棵树，要求树上每个点都要有人看守，在不同的点安排守卫所需 \(Monney\) 不同。

守卫站在某个端点上时，他除了能看守住他所站的那个点，也能看守通过一条边与之相连的另一个端点，因此一个守卫可能同时能看守住多个点，因此没有必要在每个端点上都安排守卫。

要求在能够看守住所有点的前提下，使得花费的 \(Monney\) 最少。

【输入】

第 \(1\) 行一个整数 \(n\)，表示树中节点的数目。

接下来 \(n\) 行，每行描述每个结点的信息，依次为：该结点标号 \(i\)，在该结点安置保安所需的经费 \(k_i\)，该边的儿子数 \(m\)，接下来 \(m\) 个数，分别是这个节点的 \(m\) 个儿子的标号 \(r_1,r_2,r_3...r_m\)。

对于一个 \(n\) 个结点的树，其结点标号在 \(1\) 到 \(n\) 之间，且标号不重复。

【输出】

输出一行一个整数，表示花费的最少 \(Monney\) 。

【样例】

样例输入：
6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0

样例输出：
25

【数据范围】

\(100\%\) \(1 \leqslant N \leqslant 1500,1 \leqslant k_i \leqslant 10000\)

---

【分析】

一道经典的树形 \(dp\) 。

用 \(dp[i][0]\) 表示：自己不是守卫，父亲不是守卫，儿子是守卫。

用 \(dp[i][1]\) 表示：自己是守卫，父亲不知道，儿子不知道。

用 \(dp[i][2]\) 表示：自己不是守卫，父亲是守卫，儿子不知道。

在树上 \(dfs\) 遍历。

每到达一个 \(x\)，先对其进行初始化：\(dp[x][1]=w[x],dp[x][2]=dp[x][0]=0\)（其中 \(w[x]\) 为在 \(x\) 这个位置放守卫所需 \(Monney\)）。

然后遍历它的若干个儿子结点，更新三个 \(dp[x][?]\)：

\((1).\) \(dp[x][1]\)：\(x\) 是守卫，\(x\) 的父亲不知道，\(x\) 的儿子 \(to\) 不知道。

对于 \(to\) 来说，\(to\) 的父亲一定是守卫，所以 \(dp[to][0]\) 就不统计了，于是有：\(dp[x][1]=\sum_{to \in son[x]} min(dp[to][1],dp[to][2])\)

\((2).\) \(dp[x][2]\)：\(x\) 不是守卫，\(x\) 的父亲是守卫，\(x\) 的儿子 \(to\) 不知道

对于 \(to\) 来说，\(to\) 的父亲不可能是守卫，于是有：\(dp[x][2]=\sum_{to \in son[x]} min(dp[to][1],dp[to][0])\)

\((3).\) \(dp[x][0]\)：\(x\) 不是守卫，\(x\) 的父亲不是守卫，\(x\) 的儿子 \(to\) 是守卫

这是最复杂的情况，需要在 \(son[x]\) 选出一个 \(dp[to][1]\)，而其他的儿子则是 \(min(dp[to][1],dp[to][0])\)。

可以对所有儿子维护一个 \(dp[to][1]\) 与 \(min(dp[to][1],dp[to][0])\) 的差值 \(dd\)，然后在最后把最小的差值 \(dd_{min}\) 加到 \(dp[to][0]\) 上即可。

于是 \(dd={(dp[r][1]-min(dp[r][0],dp[to][1]))}^{r \in son[x]}_{min},\) \(dp[to][0]=\sum_{to \in son[x]} min(dp[r][1],dp[r][0])+dd\)

【Code】

#include<algorithm>
#include<cstring>
#include<cstdio>
#define R register int
using namespace std;
struct QAQ{int to,next;}a[1505];
int m,pan[1505],n,t,w[1505],dp[1505][3],head[1505];
inline void add(int x,int y){a[++t].to=y,a[t].next=head[x],head[x]=t;}
//dp[i][0] 自己不是守卫，父亲不是守卫，儿子是守卫
//dp[i][1] 自己是守卫，  父亲不知道，  儿子不知道
//dp[i][2] 自己不是守卫，父亲是守卫，  儿子不知道
inline void dfs(int x){
    R i,to,dd=0xfffffff;
    dp[x][1]=w[x];dp[x][2]=0;dp[x][0]=0;
    for(i=head[x];i;i=a[i].next){
        dfs(to=a[i].to);
        dd=min(dd,dp[to][1]-min(dp[to][0],dp[to][1]));//维护最小的差值
        dp[x][0]+=min(dp[to][0],dp[to][1]);
        //若x守卫是儿子dp[x][0]，找到花费最小的dd 加上其他的儿子：min(1.孙子dp[to][0]。2.自己dp[to][1]。)
        dp[x][1]+=min(dp[to][1],dp[to][2]);
//若x有守卫dp[x][1]，加上儿子：min(1.父亲dp[to][2]。2.自己dp[to][1]。)
        dp[x][2]+=min(dp[to][0],dp[to][1]);
//若守卫是父亲dp[x][2]，加上儿子：min(1.孙子dp[to][0]。2.自己dp[to][1]。)
    }
    dp[x][0]+=dd;
}
int main(){
  memset(dp,127,sizeof(dp));
    scanf("%d",&n);
    R i,j,a,k,r;
    for(i=1;i<=n;i++){
        scanf("%d%d%d",&a,&k,&m);w[a]=k;
        for(j=1;j<=m;j++)scanf("%d",&r),pan[r]=1,add(a,r);
    }
    for(i=1;i<=n;i++)
        if(!pan[i]){
            dfs(i);
            printf("%d",min(dp[i][1],dp[i][0]));
            return 0;
        }
}