UVALive 6584 Escape (Regionals 2013 >> Europe - Central)

题目

给出一棵树，每个节点有一个怪物或血药，遇到怪物必须打，打完后扣掉一定的血量。

一开始英雄的血量为\(0\)，当血量小于\(0\)时就挂了。

给出英雄的起点和终点，问能否成功到达终点。

算法

这题的方法真的是太美妙了！感觉ACM的题目比OI的好多了，因为它的程序不长，并且每题都不容易想啊。

我们先来解决一个弱化版问题：把起点作为根，问英雄最多能加多少血。

我们可以想象每个点有一个礼包，这个礼包有两个属性，不妨用\((a,b)\)表示，表示当英雄的血量不少于\(a\)时可以加上\(b\)点血量（\(b\)是负数就减血量）。但是有些限制，如果要取某个礼包，那么它的所有祖先上的礼包都必须先取。

我们现在尝试对每棵子树维护一些礼包，首先要保证所有的礼包都是奖励的。我们不妨假设现在对于点\(v\)，要根据它的所有儿子\(u_i\)的礼包合成点\(v\)子树的礼包。对于点\(v\)，如果它有怪物，我们就要想办法通过提高\(a\)使得\(b\)变为非负数（提高\(a\)是为了取子树的礼包），如果不行，那么这棵子树是不可能走进去的（因为走进去就一定扣血啊）。

通过提高\(a\)的值，现在我们成功地在点\(v\)已经生成了一个礼包，如此下去，我们对于根就生成了一棵礼包树，每个点都是有奖励的！我们就贪心（先选\(a\)最小的）往下走就好了，这个贪心的话，可以用一个左偏树来维护礼包。每开启一个礼包，就把这个礼包的儿子也加进去。

解决了这个弱化版问题后，剩下的就简单了。

代码

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

typedef long long i64;

const int MAXN = (int) 2e5 + 3;

int n, target;
int A[MAXN];

struct Node{
Node* s[2];
int dis;
i64 minus, plus;

void init() {
s[0] = s[1] = NULL;
dis = 0;
minus = plus = 0;
}
};
Node node[MAXN];

struct Edge {
Edge* next;
int to;
};

Edge mem[MAXN * 2];
Edge* info[MAXN];
Edge* curMem;

void insert(int a, int b) {
curMem->to = b;
curMem->next = info[a];
info[a] = curMem ++;
}

Node* merge(Node* x, Node* y) {
if (! x) return y;
if (! y) return x;
if (x->minus > y->minus) swap(x, y);
x->s[1] = merge(x->s[1], y);
if (x->s[1] ? x->s[1]->dis : 0 > x->s[0] ? x->s[0]->dis : 0)
swap(x->s[0], x->s[1]);
x->dis = x->s[1] ? x->s[1]->dis + 1 : 1;
return x;
}

int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif

scanf("%*d");
while (scanf("%d%d", &n, &target) == 2) {
curMem = mem;
memset(info, 0, sizeof info);
for (int i = 1; i <= n; i ++)
scanf("%d", A + i);

for (int i = 1; i < n; i ++) {
int v, u;
scanf("%d%d", &v, &u);
insert(v, u);
insert(u, v);
}

static int que[MAXN];
static int fa[MAXN];
memset(fa, 0, sizeof fa);
int low = 0, high = 0;
que[high ++] = target;
while (low < high) {
int v = que[low ++];
for (Edge* pt = info[v]; pt; pt = pt->next) {
int u = pt->to;
if (u != fa[v]) {
fa[u] = v;
que[high ++] = u;
}
}
}

static bool path[MAXN];
memset(path, 0, sizeof path);
for (int v = 1; v != 0; v = fa[v])
path[v] = true;

for (int i = high - 1; i > 0; i --) {
int v = que[i];
if (path[v]) continue;

Node* son = NULL;
for (Edge* pt = info[v]; pt; pt = pt->next)
if (! path[pt->to] && pt->to != fa[v])
son = merge(son, &node[pt->to]);

Node* cur = node + v;
cur->init();
cur->minus = max(0, - A[v]);
cur->plus = A[v];

while (son && (cur->plus < 0 || cur->minus > son->minus)) {
if (cur->plus < 0) {
cur->minus = max(cur->minus, son->minus - cur->plus);
cur->plus += son->plus;
}
else {
cur->plus += son->plus;
}
son = merge(son->s[0], son->s[1]);
}

cur = merge(cur, son);
if (cur->plus < 0) cur = NULL;
}

i64 hp = 0;
bool ok = true;
Node* tree = NULL;
for (int v = 1; v != 0; v = fa[v]) {
hp += A[v];
if (hp < 0) {
ok = false;
break;
}
for (Edge* pt = info[v]; pt; pt = pt->next) {
int u = pt->to;
if (path[u]) continue;
if (u == fa[v]) continue;
tree = merge(tree, &node[u]);
}
while (tree && hp >= tree->minus) {
hp += tree->plus;
tree = merge(tree->s[0], tree->s[1]);
}
}

if (ok) printf("escaped\n");
else printf("trapped\n");
}

return 0;
}