BZOJ 3669: [Noi2014]魔法森林

Description

为了得到书法大家的真传,小E同学下定决心去拜访住在魔法森林中的隐士。魔法森林可以被看成一个包含个N节点M条边的无向图,节点标号为1..N,边标号为1..M。初始时小E同学在号节点1,隐士则住在号节点N。小E需要通过这一片魔法森林,才能够拜访到隐士。

魔法森林中居住了一些妖怪。每当有人经过一条边的时候,这条边上的妖怪就会对其发起攻击。幸运的是,在号节点住着两种守护精灵:A型守护精灵与B型守护精灵。小E可以借助它们的力量,达到自己的目的。

只要小E带上足够多的守护精灵,妖怪们就不会发起攻击了。具体来说,无向图中的每一条边Ei包含两个权值Ai与Bi。若身上携带的A型守护精灵个数不少于Ai,且B型守护精灵个数不少于Bi,这条边上的妖怪就不会对通过这条边的人发起攻击。当且仅当通过这片魔法森林的过程中没有任意一条边的妖怪向小E发起攻击,他才能成功找到隐士。

由于携带守护精灵是一件非常麻烦的事,小E想要知道,要能够成功拜访到隐士,最少需要携带守护精灵的总个数。守护精灵的总个数为A型守护精灵的个数与B型守护精灵的个数之和。

Input

第1行包含两个整数N,M,表示无向图共有N个节点,M条边。 接下来M行,第行包含4个正整数Xi,Yi,Ai,Bi,描述第i条无向边。其中Xi与Yi为该边两个端点的标号,Ai与Bi的含义如题所述。 注意数据中可能包含重边与自环。

Output

输出一行一个整数:如果小E可以成功拜访到隐士,输出小E最少需要携带的守护精灵的总个数;如果无论如何小E都无法拜访到隐士,输出“-1”(不含引号)。

Sample Input

【输入样例1】

4 5

1 2 19 1

2 3 8 12

2 4 12 15

1 3 17 8

3 4 1 17

【输入样例2】

3 1

1 2 1 1

Sample Output

【输出样例1】

32

【输出样例2】

-1

HINT

【样例说明1】

如果小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个守护精灵。

【样例说明2】

小E无法从1号节点到达3号节点,故输出-1。2<=n<=50,000

0<=m<=100,000

1<=ai ,bi<=50,000

Solution

先对Ai排序,然后用LCT维护Bi的最小生成树即可。假设当前枚举到了排序后的第i条边,对答案的贡献为:\(A_i+max\_edge(1,n)\),max_edge(u,v)表示从u到v的路径中最长边为多少。

Code

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const int INF = 1<<30;
typedef long long LL;
const int N = 160005;
struct edge_type {
	int x, y, a, b;
} edge[N];
int getint() {
	int r=0,k=1; char c=getchar();
	for(;'0'>c||c>'9';c=getchar()) if(c=='-')k=-1;
	for(;'0'<=c&&c<='9';c=getchar()) r=r*10-'0'+c;
	return r*k;
}
bool cmpa(edge_type x, edge_type y) {
	return x.a<y.a;
}
int c[N][2], fa[N], mx[N], rev[N], mxid[N], st[N], p[N];
bool isroot(int x) { return !(c[fa[x]][0]==x||c[fa[x]][1]==x); }
void pd(int x) {
	int &l = c[x][0], &r = c[x][1];
	if (rev[x]) {
		rev[x] = 0; rev[l] ^= 1; rev[r] ^= 1;
		swap(l, r);
	}
}
void pu(int x) {
	int &l = c[x][0], &r = c[x][1];
	if (mx[l] > mx[r]) {
		mx[x] = mx[l];
		mxid[x] = mxid[l];
	} else {
		mx[x] = mx[r];
		mxid[x] = mxid[r];
	}
	if (p[x] > mx[x]) {
		mx[x] = p[x];
		mxid[x] = x;
	}
}
void rotate(int x) {
	int y = fa[x], z = fa[y], a=(c[y][1]==x), b=!a;
	if (!isroot(y)) c[z][c[z][1]==y]=x;
	fa[x]=z; fa[y]=x; fa[c[x][b]]=y;
	c[y][a]=c[x][b]; c[x][b]=y;
	pu(y); pu(x);
}
void splay(int x) {
	int t = 1; st[1] = x;
	for (int i = x; !isroot(i); i = fa[i]) st[++t] = fa[i];
	while (t) pd(st[t--]);
	while (!isroot(x)) {
		int y = fa[x], z = fa[y];
		if (!isroot(y)) {
			if (c[z][0]==y^c[y][0]==x) rotate(x);
			else rotate(y);
		}
		rotate(x);
	}
}
void access(int x) {
	int y = 0;
	while (x) {
		splay(x);
		c[x][1] = y;
		pu(x);
		y = x;
		x = fa[x];
	}
}
void mkrt(int x) {
	access(x);
	splay(x);
	rev[x] ^= 1;
}
void link(int x, int y) {
	mkrt(x);
	fa[x] = y;
	splay(x);
}
void cut(int x, int y) {
	mkrt(x);
	access(y);
	splay(y);
	fa[x] = 0;
	c[y][0] = 0;
}
int findrt(int x) {
	access(x);
	splay(x);
	while (c[x][0]) x = c[x][0];
	return x;
}
void add(int eid) {
	int x = edge[eid].x, y = edge[eid].y;
	if (findrt(x) != findrt(y)) {
		link(x, eid+50006);
		link(eid+50006, y);
		return;
	}
	mkrt(x); access(y); splay(y);
	if (mx[y] <= edge[eid].b) return;
	int tmp = mxid[y];
	cut(edge[tmp-50006].x, tmp);
	cut(tmp, edge[tmp-50006].y);
	link(x, eid+50006);
	link(y, eid+50006);
}
int query(int x, int y) {
	if (findrt(x) != findrt(y)) return INF;
	mkrt(x); access(y); splay(y);
	return mx[y];
}
int n, m, ans = INF;
int main () {
	n=getint(); m=getint();
	for (int i = 1; i <= m; ++i) {
		edge[i].x=getint();
		edge[i].y=getint();
		edge[i].a=getint();
		edge[i].b=getint();
	}
	sort(edge+1, edge+m+1, cmpa);
	for (int i = 1; i <= m; ++i) p[i+50006] = edge[i].b;
	for (int i = 1; i <= m; ++i) {
		add(i);
		ans = min(ans, query(1,n)+edge[i].a);
	}
	if (ans == INF) printf("-1");
	else printf("%d", ans);
}