洛谷P2279 树上背包，树形dp

最新推荐文章于 2024-10-31 16:56:58 发布

原创最新推荐文章于 2024-10-31 16:56:58 发布 · 595 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#深度优先 #算法

博客围绕有n个城市被n - 1条道路连接的问题展开，探讨至少建多少个消防站能及时扑灭各地火灾。采用树形dp方法，设置状态f[u][k]，分析不同k值下的状态转移方程，最后将“恰好覆盖”改为“可以覆盖”避免边界处理难题。

题意：

有 $n$ 个城市，被 $n - 1$ 条道路连接着，每个节点可以建一个消防站，每个消防站可以及时扑灭与自己距离不超过2的地方发生的火灾，问至少建多少个消防站，使得无论哪里发生火灾都能被及时扑灭，不妨假设每个消防站的人力都是无限的

Solution：

树形dp，状态可以这样设置，设 $f [u] [k]$ 为恰好覆盖到 $u$ 往上 $k$ 距离的最小消防站数量，不妨只考虑如下的 $k\in\{-2,-1,0,1,2\}$ ，先不分析为什么是这样子，来考虑转移：

如果需要覆盖到往上2个距离的，那么当前位置一定需要建消防站，并且与 $u$ 距离 $\leq2$ 的都不需要建立，所以下面的部分只需要覆盖到距离 $u$ 为 $- 3$ 的地方，即儿子的 $- 2$ 的地方，即

$f[u][2]=1+\sum_{v\in son_{u}}f[v][-2]$

如果需要覆盖到往上1个距离的，只需要一个儿子往上覆盖2，并且这个儿子会把别的儿子的覆盖掉，所以其他儿子只需要覆盖到-1即可，即

$f[u][1]=min(f[v][1]+\sum_{v'\in son_{u},v\neq v'}f[v'][-1])$

如果只需要覆盖到自己，那么一个儿子往上覆盖1，其他儿子都需要覆盖到自己即可，即

$f[u][0]=min(f[v][1]+\sum_{v\in sum_{u},v\neq v'}f[v'][0])$

如果只需要覆盖到-1位置，即每个儿子覆盖到自己本身

$f[u][-1]=\sum_{v\in son_{u}}f[v][0]$

如果只需要覆盖到-2位置，即儿子覆盖到自己本身的-1位置

$f[u][-2]=\sum_{v\in son_{u}}f[v][-1]$

由于恰好覆盖，其边界难处理，应该需要剖分长儿子，来看当前位置是否能实现往下-1，-2，以及能否实现往上1，2；假如树是一条很短的链，那么就算剖分完也不好更新。不妨把状态中恰好二字改为可以，那么就不需要处理这样的问题，此时， $f [u] [k]$ 还需要与 $f [u] [k + 1], f [u] [k + 2], ..., f [u] [2]$ 取最小值，因为能覆盖的更高的必然会是覆盖的低的一种可行方案

再来解释为什么 $k\in[-2,2]$ ，看上面的转移，显然最大的偏移量是-3，但这个可以通过儿子来变成-2，于是只需要这个区间的即可

最后只需要给数组加上偏移量即可

// #include<bits/stdc++.h>
#include<iostream>
#include<queue>
#include<cstdio>
#include<bitset>
#include<cstring>
#include<map>
#include<algorithm>
using namespace std;

using ll=long long;
const int N=1005,inf=0x3fffffff;
const long long INF=0x3f3f3f3f3f3f,mod=998244353;

struct way
{
    int to,next,w;
}edge[N<<1];
int cnt,head[N];

void add(int u,int v,int w=0)
{
    edge[++cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt;
}

int n,depth[N],max1[N];
ll dp[N][5];

ll& f(int u,int x){return dp[u][x+2];}

void dfs1(int u,int fa)
{
    depth[u]=max1[u]=depth[fa]+1;
    for(int i=head[u];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==fa) continue;
        dfs1(v,u);
        max1[u]=max(max1[u],max1[v]);
    }
}

void dfs(int u,int fa)
{
    f(u,2)=1;
    ll min1=INF,min2=INF;
    for(int i=head[u];i;i=edge[i].next)
    {
        int v=edge[i].to;
        if(v==fa) continue;
        dfs(v,u);
        f(u,2)+=f(v,-2);
        f(u,1)+=f(v,-1);
        min1=min(min1,f(v,2)-f(v,-1));
        f(u,0)+=f(v,0);
        min2=min(min2,f(v,1)-f(v,0));
        f(u,-1)+=f(v,0);
        f(u,-2)+=f(v,-1);
    }
    if(min1!=inf)
    {
        f(u,1)+=min1;
        f(u,0)+=min2;
    }
    else f(u,1)=f(u,0)=1,f(u,-1)=f(u,-2)=0;
    for(int i=1;i>=-2;i--) f(u,i)=min(f(u,i),f(u,i+1));
}

int main()
{
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=2;i<=n;i++)
    {
        int x; cin>>x;
        add(i,x); add(x,i);
    }
    dfs(1,0);
    cout<<f(1,0);
    return 0;
}