[洛谷]P2279 [HNOI2003]消防局的设立 (#树形dp)

题目描述

2020年，人类在火星上建立了一个庞大的基地群，总共有n个基地。起初为了节约材料，人类只修建了n-1条道路来连接这些基地，并且每两个基地都能够通过道路到达，所以所有的基地形成了一个巨大的树状结构。如果基地A到基地B至少要经过d条道路的话，我们称基地A到基地B的距离为d。

由于火星上非常干燥，经常引发火灾，人类决定在火星上修建若干个消防局。消防局只能修建在基地里，每个消防局有能力扑灭与它距离不超过2的基地的火灾。

你的任务是计算至少要修建多少个消防局才能够确保火星上所有的基地在发生火灾时，消防队有能力及时扑灭火灾。

输入格式

输入文件名为input.txt。

输入文件的第一行为n （n<=1000），表示火星上基地的数目。接下来的n-1行每行有一个正整数，其中文件第i行的正整数为a[i]，表示从编号为i的基地到编号为a[i]的基地之间有一条道路，为了更加简洁的描述树状结构的基地群，有a[i]<i。

输出格式

输出文件名为output.txt

输出文件仅有一个正整数，表示至少要设立多少个消防局才有能力及时扑灭任何基地发生的火灾。

输入输出样例

输入 #1复制

6
1
2
3
4
5

输出 #1复制

2

---

思路

其实和P2899 [USACO08JAN]手机网络有点类似，有兴趣的同学可以去看一看，该题我也写了题解。链接1 链接2

题目大意是给出一个树，一个消防站能够覆盖与他距离≤2的点。求覆盖整个树的所有节点至少需要多少个消防站。

树形dp的常规操作是每个节点都可以成为根节点，然后在这个节点搜索它的子树获取最优解。这个我在P2016那题说过。我们根据P2899那题的经验，对一颗子树划分为5个状态。

令dp[i][0/1/2/3/4]为节点i及其节点i的子树中全部被覆盖所需的最小消防局数。dp[i][0]为节点i父亲的父亲及以下节点完全被覆盖所需的最小代价，dp[i][1]为节点i的父亲及以下节点完全被覆盖所需的最小代价，dp[i][2]为节点i及以下节点完全被覆盖所需要的最小代价。显然，这3种情况是节点i一定被覆盖的情况。

dp[i][3]为节点i的儿子及以下节点完全被覆盖所需最小代价，dp[i][4]为节点i儿子的儿子及以下节点完全被覆盖所需的最小代价。显然，这2种情况是节点i不一定被覆盖的情况。是不是和P2899迷之相似？这样感觉就对了！

简段洁说，dp[i][0]:选i为消防局；dp[i][1]:至少选i的一个儿子为消防局；dp[i][2]:至少选i的一个孙子为消防局。这3种状态显然节点i被覆盖。dp[i][3]:选i的所有儿子被覆盖;dp[i][4]:选i的所有孙子被覆盖。这2种状态节点i不一定被覆盖。

1.1.dp[i][0]

因为节点i有消防局，所以孙子会被覆盖到。要求孙子全部被覆盖，儿子0-4的状态都满足。所以：

dp[i][0]=min(Σdp[son][0...4])+1

这里+1是因为本身放了一个消防局。

1.2.dp[i][1]

​选了儿子中的一个节点，所以其他儿子也会被覆盖到。但是其他儿子的儿子无法被覆盖到。所以在转移时，选取一个点放消防站，并要求i的儿子被覆盖到。

dp[i][1]=min(dp[son1][0]+Σ(son1≠son2)min(dp[son2][0...3]))

1.3.dp[i][2]

同理有：

dp[i][2]=min(dp[son1][1]+Σ(son1≠son2)min(dp[son2][0...2]))

1.4.dp[i][3]

要让节点i的儿子都被覆盖，就是让它们本身都覆盖。

dp[i][3]=Σdp[son][0...2]

1.5.dp[i][4]

同理有：

dp[i][4]=Σdp[son][0...3]

推好了！可是......特别的乱！多！烦！那就看能不能合并吧。

2.1.dp[i][0],dp[i][3],dp[i][4]

dp[i][0]可以从4个儿子节点的状态里得到。但显然dp[son][4]是最优的。因为dp[son][4]=Σdp[grandson][0...3]。

所以：

dp[i][0]=Σdp[son][4]

同理有：

dp[i][3]=Σdp[son][2]

dp[i][4]=Σdp[son][3]

状态0,3,4已经优化完成，事实上我们还可以利用它们进行优化状态1,2。

2.2.dp[i][1],dp[i][2]

dp[i][1]=min(dp[son1][0]+Σ(son1!=son2)dp[son2][0...3])

=dp[i][4]+min(dp[son1][0]-dp[son1][3])

同理有：

dp[i][2]=min(dp[son1][1]+Σ(son1≠son2)min(dp[son2][0...2]))

=dp[i][3]+min(dp[son1][2]-dp[son1][1])

#include <stdio.h>
#include <iostream>
#define inf 2e9+7
#define N 1001
using namespace std;
int n,cnt,head[N],s,dp[N][5];
struct node
{
	int to,nxt;
}e[N<<1];
inline void add(int u,int v)
{
	e[++cnt].to=v;
	e[cnt].nxt=head[u];
	head[u]=cnt;
}
void dfs(int u,int fa)
{
	dp[u][1]=inf;
	dp[u][2]=inf;
	register int j,i;
	for(i=head[u];i;i=e[i].nxt)
	{
		int v(e[i].to);
		if(v==fa) continue;
		dfs(v,u);
		dp[u][0]+=dp[v][4];
		dp[u][3]+=dp[v][2];
		dp[u][4]+=dp[v][3];
		dp[u][2]=min(dp[u][2],dp[v][1]-dp[v][2]);
		dp[u][1]=min(dp[u][1],dp[v][0]-dp[v][3]);
		
	}
	dp[u][0]++;
	dp[u][2]+=dp[u][3];
	dp[u][1]+=dp[u][4];
	dp[u][1]=min(dp[u][1],dp[u][0]);
	dp[u][2]=min(dp[u][2],dp[u][1]);
	dp[u][3]=min(dp[u][3],dp[u][2]);
	dp[u][4]=min(dp[u][4],dp[u][3]);
}
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	register int i,j;
	cin>>n;
	for(i=2;i<=n;i++)
	{
		int u;
		cin>>u;
		add(u,i);
		add(i,u);
	}
	dfs(1,-1);
	cout<<dp[1][2]<<endl;
	return 0;
}