BZOJ 3669 [Noi2014]魔法森林 Kruskal+LCT

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
【样例说明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】


-1
【样例说明2】
小E无法从1号节点到达3号节点，故输出-1。

HINT

2<=n<=50,000

0<=m<=100,000

1<=ai ,bi<=50,000

Source

题目链接

题目意思就是每条边有两种权值a,b，
然后1~n走过的路上取最大的ai和bi相加就是这条路的花费。
要求的就是最小花费。
其实可以看成最小生成树的双关键版本。。。
首先把ai用Kruskal的方法从小到大加边。
但是如果对于当前ui和vi已经联通，那么就是要判断一下这条边bi的加入是否会更优。
用这条边去替换原来生成树里bi最大的一条边。
当然替换的话，首先要删除这条边。。（可持久化生成树……）
这个过程用LCT来维护。。

另外这题值得一提的是边权。
在树链剖分这种静态结构，完全可以把边权转化为点权，具体不说了。
但是LCT由于树会一直切、合、切、合……所以就不能这么做了。
具体做法就是把边看成点，m条边看成n+1号，n+2号……n+m号。
然后维护的时候，比如cut(u,v)，u->v的边编号是w，那么cut(u,w),cut(v,w)
同理link的时候，link(u,w);link(v,w).

up的地方错了好久！！
tree[son[0]].max这个地方总是打成son[0]....气啊调了炒鸡久。。。

#include<bits/stdc++.h>
using namespace std;
int read(){
    int x=0,f=1;char ch=getchar();
    while (ch<'0' || ch>'9'){if (ch=='-') f=-1;ch=getchar();}
    while (ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int 
	Nodem=50005,
	Edgem=100005;
int n,m,fa[Nodem+Edgem];
struct Edge{
	int u,v,a,b;
}E[Edgem];
struct LCT{
	int pre,son[2],Max,rev,val;
}tree[Nodem+Edgem];
int getfa(int x){
	if (x!=fa[x]) fa[x]=getfa(fa[x]);
	return fa[x];
}
bool isroot(int x){
	return tree[tree[x].pre].son[0]!=x &&
		   tree[tree[x].pre].son[1]!=x;
}
bool cmp(Edge x,Edge y){
	return x.a<y.a;
}
void up(int x){
	if (x){
		tree[x].Max=x;
		if (tree[tree[x].Max].val<tree[tree[tree[x].son[0]].Max].val)
			tree[x].Max=tree[tree[x].son[0]].Max;
		if (tree[tree[x].Max].val<tree[tree[tree[x].son[1]].Max].val)
			tree[x].Max=tree[tree[x].son[1]].Max;
	}
}
void down(int x){
	if (x && tree[x].rev){
		swap(tree[x].son[0],tree[x].son[1]);
		tree[tree[x].son[0]].rev^=1;
		tree[tree[x].son[1]].rev^=1;
		tree[x].rev^=1;
	}
}
void Rotate(int x){
    int y=tree[x].pre,z=tree[y].pre,l,r;
    if (tree[y].son[0]==x) l=0; else l=1;
	r=l^1;
    if (!isroot(y))
        if (tree[z].son[0]==y)
			tree[z].son[0]=x; else	tree[z].son[1]=x;
    tree[x].pre=z;	tree[y].pre=x;
	tree[tree[x].son[r]].pre=y;
    tree[y].son[l]=tree[x].son[r];
	tree[x].son[r]=y;
	up(y); up(x);
}
int stk[Nodem+Edgem];
void splay(int x){
	int top=0;	stk[++top]=x;
	for (int i=x;!isroot(i);i=tree[i].pre)
		stk[++top]=tree[i].pre;
	for (int i=top;i;i--) down(stk[i]);
	while (!isroot(x)){
		int y=tree[x].pre,z=tree[y].pre;
		if (!isroot(y))
			if (tree[y].son[0]==x^tree[z].son[0]==y) Rotate(x);
				else Rotate(y);
		Rotate(x);
	}
}
void access(int x){
	for (int y=0;x;y=x,x=tree[x].pre)
		splay(x),tree[x].son[1]=y,up(x);
}
void makeroot(int x){
	access(x);
	splay(x);
	tree[x].rev^=1;
}
void split(int x,int y){
	makeroot(x);
	access(y); splay(y);
}
void cut(int x,int y){
	split(x,y);
	tree[x].pre=tree[y].son[0]=0;
	up(y);
}
void link(int x,int y){
	makeroot(x);
	tree[x].pre=y;
}
int query(int x,int y){
	split(x,y);
	return tree[y].Max;
}
int main(){
	n=read(),m=read();
	for (int i=1;i<=m;i++)
		E[i].u=read(),E[i].v=read(),E[i].a=read(),E[i].b=read();
	sort(E+1,E+1+m,cmp);
	for (int i=1;i<=n;i++) fa[i]=i;
	int ans=100000000;
	for (int i=1;i<=m;i++){
		int t1=getfa(E[i].u),t2=getfa(E[i].v);
		if (t1==t2){
			int t=query(E[i].u,E[i].v);
			if (tree[t].val>E[i].b){
				cut(t,E[t-n].u);
				cut(t,E[t-n].v);
			}	else{
				if (getfa(1)==getfa(n))
					ans=min(ans,E[i].a+tree[query(1,n)].val);
				continue;
			}
		}	else fa[t1]=t2;
		tree[n+i].val=E[i].b; tree[n+i].Max=n+i;
		link(E[i].u,n+i),link(E[i].v,n+i);
		if (getfa(1)==getfa(n))
			ans=min(ans,E[i].a+tree[query(1,n)].val);
	}
	if (ans==100000000) puts("-1");
		else	printf("%d\n",ans);
	return 0;
}