洛谷2279 03湖南 消防局的设立

洛谷2279 03湖南 消防局的设立

本题地址： http://www.luogu.org/problem/show?pid=2279

题目描述

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

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

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

输入输出格式

输入格式：

输入文件名为input.txt。

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

输出格式：

输出文件名为output.txt

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

输入输出样例

输入样例#1：

6

1

2

3

4

5

输出样例#1：

2

这道题我表示无能为力，研究了2天，总算搞了出来，借助了网上的题解。

类比距离为1的题，这题应该是树形dp，但是状态可能会多一些

f[i][0]: 表示选了自己

f[i][1]: 表示选了儿子

f[i][2]: 表示选了孙子

——上面用来表示这个点被覆盖了的状态，下面为这个点没有被覆盖的状态

f[i][3]: 表示自己不一定被覆盖，但是儿子一定全部被覆盖

f[i][4]: 表示自己和儿子都不一定被覆盖，但是孙子一定全部都被覆盖

2、状态的更新（有点难理解，但是这道题一定要迈过去的坎）

f[i][0] = 1+Σmin(f[j][0…4]);

f[i][1] = min( f[k][0] + Σ(j != k)min(f[j][0…3]) );

f[i][2] = min( f[k][1] + Σ(j != k)min(f[j][0…2]) );

f[i][3] = Σf[j][0…2];

f[i][4] = Σf[j][0…3];

3、状态的简化

上面的状态貌似已经可以搞了，但是我们发现上面有很多…，可以合并

令f[i][j] = min(f[i][0…j]) (j >= 1)

f[i][0] = 1+Σf[j][4];

f[i][1] = min( f[k][0] + Σ(j != k)f[j][3] )

= Σf[j][3] + min(f[k][0]-f[k][3])

= f[i][4] + min(f[k][0]-f[k][3]);

f[i][2] = min( f[k][1] + Σ(j != k)f[j][2] )

= Σf[j][2] + min(f[k][1]-f[k][2])

= f[i][3] + min(f[k][1]-f[k][2]);

f[i][3] = Σf[j][2];

f[i][4] = Σf[j][3];

最后再更新一遍，使得f[i][j] = min(f[i][0…j]) (j >= 1)

f[1][2]即为答案，O(n+m)的复杂度(貌似n为1000，邻接矩阵n^2也可通过)

我的代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>

using namespace std;
const int maxn=1010, INF=2100000000;
int f[maxn][5];
vector<int> G[maxn];
void dp(int u, int fa)
{
f[u][0]=1;
f[u][1]=f[u][2]=INF;
f[u][3]=f[u][4]=0;
bool son=0;
for (int i=0; i<G[u].size(); i++)
{
int v=G[u][i];
if (v!=fa)
{
son=1;
dp(v, u);
f[u][0]+=f[v][4];
f[u][3]+=f[v][2];
f[u][4]+=f[v][3];
}
}
for (int i=0; i<G[u].size(); i++)
{
int v=G[u][i];
if (v!=fa)
{
f[u][1]=min(f[u][1], f[u][4]-f[v][3]+f[v][0]);
f[u][2]=min(f[u][2], f[u][3]-f[v][2]+f[v][1]);
}
}
for (int i=1; i<=4; i++) f[u][i]=min(f[u][i-1], f[u][i]);
}

int main()
{
int n;
scanf("%d", &n);
for (int u=2; u<=n; u++)
{
int v;
scanf("%d", &v);
G[u].push_back(v);
G[v].push_back(u);
}
dp(1, -1);
printf("%d\n", f[1][2]);
return 0;
}