hdu 5290 Bombing plan（树形dp）

题目链接：hdu 5290 Bombing plan

dpDestroy[u][i]表示以u为根节点的子树全部被摧毁，并且向上还可以破坏到距离u为i的城市；dpSafe[u][i]表示以u为根节点的子树中有距离u深度为i的城市还未被破坏。

dpDestroy[u][i] = dpDestroy[v][i+1] + sum{ min(dpDestroy[k][j], dpSafe[k][j])（j≤i）| k为除了v以外的子节点}

dpSafe[u][i] = dpSafe[v][i-1] + sum{ min(dpSafe[k][j], dpDestroy[k][j]) （j≤i）| k为除了v以外的子节点}

然后在转移一下u节点放炸弹的情况，这样的直接做的复杂度是o（n * w * w）

对于每个节点，可以维护一个前缀最小值，加速查询，minDestroy[u][i] = min{ dpDestroy[u][j] （j≤i）}

#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;
const int maxn = 1e5 + 5;
const int maxm = 100;
const int inf = 0x3f3f3f3f;

int N, W[maxn], dpDestroy[maxn][maxm + 5], dpSafe[maxn][maxm + 5];
int minDestroy[maxn][maxm + 5], minSafe[maxn][maxm + 5];
vector<int> G[maxn];

void init () {
for (int i = 1; i <= N; i++) {
scanf("%d", &W[i]);
G[i].clear();
}

int u, v;
for (int i = 1; i < N; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
}

void dfs (int u, int f) {
for (int i = 0; i <= maxm; i++)
dpDestroy[u][i] = dpSafe[u][i] = N;

int tmp = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == f)
continue;

dfs(v, u);
tmp += min(minDestroy[v][W[u]], (W[u] ? minSafe[v][W[u]-1] : inf));
}
dpDestroy[u][W[u]] = tmp + 1;

for (int i = 0; i < maxm; i++) {
int p = 0, q = 0;
for (int j = 0; j < G[u].size(); j++) {
int v = G[u][j];
if (v == f)
continue;
p += min(minDestroy[v][i + 1], (i == 0 ? inf : minSafe[v][i-1]));
q += min(minDestroy[v][i], (i == 0 ? inf : minSafe[v][i-1]));
}

for (int j = 0; j < G[u].size(); j++) {
int v = G[u][j];
if (v == f)
continue;
//dpDestroy[u][i] = min(dpDestroy[u][i], p+dpDestroy[v][i+1]-min(minDestroy[v][i+1], minSafe[v][i]));
if (i) {
dpDestroy[u][i] = min(dpDestroy[u][i], p+dpDestroy[v][i+1]-min(minDestroy[v][i+1], minSafe[v][i-1]));
dpSafe[u][i] = min(dpSafe[u][i], q + dpSafe[v][i-1] - min(minDestroy[v][i], minSafe[v][i-1]));
} else {
dpDestroy[u][i] = min(dpDestroy[u][i], p+dpDestroy[v][i+1]-min(minDestroy[v][i+1], inf));
dpSafe[u][i] = min(dpSafe[u][i], q);
}
}
}

if (G[u].size() == 1)
dpSafe[u][0] = 0;

minDestroy[u][0] = dpDestroy[u][0];
minSafe[u][0] = dpSafe[u][0];
for (int i = 1; i <= maxm; i++) {
minDestroy[u][i] = min(minDestroy[u][i-1], dpDestroy[u][i]);
minSafe[u][i] = min(minSafe[u][i-1], dpSafe[u][i]);
}
}

int main () {
while (scanf("%d", &N) == 1) {
init();
dfs(1, 0);
printf("%d\n", minDestroy[1][maxm]);
}
return 0;
}