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
", 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
", i, tree.query(1, n));
		}
	}
	printf("%d
", 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
", 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
", ans < 0x3f3f3f3f ? ans : -1);
	return 0;
}