UOJ3/bzoj3669 【NOI2014】魔法森林
UOJ3/bzoj3669 【NOI2014】魔法森林
为了得到书法大家的真传，小E同学下定决心去拜访住在魔法森林中的隐士。魔法森林可以被看成一个包含个N节点M条边的无向图，节点标号为 \(1 \dots n\) ，边标号为 $ 1 \dots m $ 。初始时小E同学在 \(1\)号节点，隐士则住在 \(n\)号节点。小E需要通过这一片魔法森林，才能够拜访到隐士。
魔法森林中居住了一些妖怪。每当有人经过一条边的时候，这条边上的妖怪就会对其发起攻击。幸运的是，在 \(1\)号节点住着两种守护精灵：A型守护精灵与B型守护精灵。小E可以借助它们的力量，达到自己的目的。
只要小E带上足够多的守护精灵，妖怪们就不会发起攻击了。具体来说，无向图中的每一条边 $ e_i $ 包含两个权值 $ a_i $ 与 \(b_i\)。若身上携带的A型守护精灵个数不少于 \(a_i\)，且B型守护精灵个数不少于 \(b_i\)，这条边上的妖怪就不会对通过这条边的人发起攻击。当且仅当通过这片魔法森林的过程中没有任意一条边的妖怪向小E发起攻击，他才能成功找到隐士。
由于携带守护精灵是一件非常麻烦的事，小E想要知道，要能够成功拜访到隐士，最少需要携带守护精灵的总个数。守护精灵的总个数为A型守护精灵的个数与B型守护精灵的个数之和。
输入格式
第1行包含两个整数 \(n,m\)，表示无向图共有 \(n\) 个节点，\(m\) 条边。
接下来 \(m\) 行，第 \(i + 1\) 行包含4个正整数 \(x_i, y_i, a_i, b_i\)，描述第 ii 条无向边。其中 \(x_i\) 与 \(y_i\) 为该边两个端点的标号，\(a_i\) 与 \(b_i\) 的含义如题所述。
注意数据中可能包含重边与自环。
输出格式
输出一行一个整数：如果小E可以成功拜访到隐士，输出小E最少需要携带的守护精灵的总个数；如果无论如何小E都无法拜访到隐士，输出\("-1"\) (不含引号)。
样例一
input
4 5
1 2 19 1
2 3 8 12
2 4 12 15
1 3 17 8
3 4 1 17
output
32
explanation
如果小E走路径1→2→4，需要携带19+15=34个守护精灵；
如果小E走路径1→3→4，需要携带17+17=34个守护精灵；
如果小E走路径1→2→3→4，需要携带19+17=36个守护精灵；
如果小E走路径1→3→2→4，需要携带17+15=32个守护精灵。
综上所述，小E最少需要携带32个守护精灵。
样例二
input
3 1
1 2 1 1
output
-1
explanation
小E无法从1号节点到达3号节点，故输出-1。
题解
LCT
LCT应该算此题的常规解法。
将边按a排序，用LCT维护b的最小生成森林。
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int BUF = 1<<16|127;
inline char gc() {
static char b[BUF], *s = b, *e = b;
if (s == e) e = (s = b) + fread(b, 1, BUF, stdin);
return (s == e) ? EOF : *s++;
}
inline void gi(int &a) {
static char c;
while (c = gc(), c < '0'); a = c - '0';
while (c = gc(), '-' < c) a = (a << 3) + (a << 1) + c - '0';
}
const int MaxN = 50005, MaxM = 100003;
struct edge {
int u, v, a, b;
} e[MaxM];
bool operator < (const edge &a, const edge &b) {
return a.a < b.a;
}
int f[MaxN];
int gf(int u) {
return (f[u] ^ u) ? f[u] = gf(f[u]) : u;
}
struct LCT {
struct node {
int val;
bool rev;
node *fa, *ch[2], *mx;
} node_mset[MaxN + MaxM], *nil;
void Init(const int &n) {
nil = node_mset;
*nil = (node) {0, false, nil, {nil, nil}, nil};
for (int i = 1; i <= n; ++i) node_mset[i] = *nil;
}
inline node *num(const int &x) {
return node_mset + x;
}
inline bool isrt(node *u) {
return (u->fa->ch[0] != u) && (u->fa->ch[1] != u);
}
inline bool which(node *u) {
return u->fa->ch[1] == u;
}
void maintain(node *u) {
u->mx = u;
if (u->ch[0]->mx->val > u->mx->val)
u->mx = u->ch[0]->mx;
if (u->ch[1]->mx->val > u->mx->val)
u->mx = u->ch[1]->mx;
}
void rot(node *u) {
node *f = u->fa;
int d = which(u);
if ((f->ch[d] = u->ch[d ^ 1]) != nil)
f->ch[d]->fa = f;
u->ch[d ^ 1] = f;
u->fa = f->fa;
if (!isrt(f)) f->fa->ch[which(f)] = u;
f->fa = u;
maintain(f);
}
void pd(node *u) {
if (!isrt(u)) pd(u->fa);
if (u->rev) {
u->ch[0]->rev ^= true;
u->ch[1]->rev ^= true;
swap(u->ch[0], u->ch[1]);
u->rev = false;
}
}
void splay(node *u) {
pd(u);
for (node *f; !isrt(u); rot(u))
if (!isrt(f = u->fa)) rot(which(u) == which(f) ? f : u);
maintain(u);
}
void access(node *x) {
for (node *y = nil; x != nil; x = x->fa)
splay(x), x->ch[1] = y, maintain(y = x);
}
void mrt(node *u) {
access(u);
splay(u);
u->rev ^= 1;
}
void link(node *u, node *v) {
mrt(u);
u->fa = v;
access(u);
}
void cut(node *u) {
splay(u);
u->ch[0]->fa = u->fa;
u->ch[1]->fa = nil;
u->fa = u->ch[0] = u->ch[1] = nil;
u->mx = u;
}
void add_edge(int u, int v, int w) {
node *_u = num(u), *_v = num(v), *_w = num(w);
if (gf(u) == gf(v)) {
mrt(_u);
access(_v);
splay(_v);
if (_v->mx->val < _w->val)
return;
cut(_v->mx);
maintain(_v);
} else
f[gf(u)] = gf(v);
link(_u, _w);
link(_v, _w);
}
int query(int u, int v) {
node *_u = num(u), *_v = num(v);
mrt(_u);
access(_v);
splay(_v);
return _v->mx->val;
}
} tree;
int main() {
//freopen("t.in", "r", stdin);
int n, m, i, ans = 0x3f3f3f3f, idx;
scanf("%d%d", &n, &m);
for (i = 0; i < m; ++i) gi(e[i].u), gi(e[i].v), gi(e[i].a), gi(e[i].b);
sort(e, e + m);
tree.Init(n + m);
for (idx = 1; idx <= n; ++idx) f[idx] = idx;
for (i = 0; i < m; ++i, ++idx) {
tree.num(idx)->val = e[i].b;
tree.add_edge(e[i].u, e[i].v, idx);
//printf("%d %d %d %d\n", e[i].u, e[i].v, e[i].a, e[i].b);
if (gf(1) == gf(n)) {
ans = min(ans, e[i].a + tree.query(1, n));
//printf("%d %d\n", i, tree.query(1, n));
}
}
printf("%d\n", ans < 0x3f3f3f3f ? ans : -1);
return 0;
}
SPFA
膜拜PoPoQQQ
看了PoPoQQQ的博客，我才知道此题可以用SPFA写。
我们在维护b的最小生成森林时，其实就是要求出1到n的最短路。
用SPFA动态求出最短路，之后各种剪枝。
SPFA跑很多数据都比LCT快，但是在UOJ上被人卡了。
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MaxN = 50005, MaxM = 100005;
inline void gi(int &a) {
static char c;
do c = getchar(); while (c < '0');
for (a = c - '0'; '-' < (c = getchar()); a = (a << 3) + (a << 1) + c - '0');
}
struct Link {
int u, v, a, b;
} e[MaxM];
bool operator < (const Link &a, const Link &b) {
return a.a < b.a;
}
struct edge {
int to, v;
edge *nxt;
} edge_mset[MaxM << 1], *cedge = edge_mset, *g[MaxN];
inline void add_edge(int u, int v, int w) {
*cedge = (edge) { v, w, g[u]};
g[u] = cedge++;
}
int d[MaxN], heap[MaxN], pos[MaxN], top;
inline void swn(int &a, int &b) {
swap(a, b);
swap(pos[a], pos[b]);
}
inline void adj(int x) {
for (int p = pos[x]; (p >> 1) && d[heap[p]] < d[heap[p >> 1]]; p >>= 1)
swn(heap[p], heap[p >> 1]);
}
inline void push(int x) {
heap[pos[x] = ++top] = x;
adj(x);
}
inline void pop() {
swn(heap[1], heap[top]);
pos[heap[top]] = 0;
heap[top--] = 0;
for (int u = 1, p; u < top; u = p) {
p = d[heap[u << 1]] < d[heap[u << 1 | 1]] ? (u << 1) : (u << 1 | 1);
if (d[heap[p]] < d[heap[u]])
swn(heap[u], heap[p]);
else
break;
}
}
inline void SPFA() {
for (int u; top; ) {
u = heap[1]; pop();
for (edge *it = g[u]; it; it = it->nxt)
if (max(d[u], it->v) < d[it->to]) {
d[it->to] = max(d[u], it->v);
if (pos[it->to]) adj(it->to);
else push(it->to);
}
}
//puts("Y");
}
int main() {
//freopen("t.in", "r", stdin);
int n, m, u, v, i, a, b, ans = 0x3f3f3f3f;
gi(n), gi(m);
for (i = 0; i < m; ++i)
gi(e[i].u), gi(e[i].v), gi(e[i].a), gi(e[i].b);
sort(e, e + m);
memset(d, 63, sizeof d);
d[1] = 0;
for (i = 0; i < m; ++i) {
u = e[i].u, v = e[i].v, a = e[i].a, b = e[i].b;
add_edge(u, v, b);
add_edge(v, u, b);
//printf("%d %d %d %d\n", u, v, a, b);
if (d[u] > d[v]) swap(u, v);
if (max(d[u], b) < d[v])
d[v] = max(d[u], b), push(v);
if (a ^ e[i + 1].a)
SPFA();
ans = min(ans, a + d[n]);
}
printf("%d\n", ans < 0x3f3f3f3f ? ans : -1);
return 0;
}
