[题解]bzoj3669(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

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

Solution

        这一题在我第一眼看到的时候觉得完全不可做，仔细一想，想到了贪心方法：先把边按照a值大小排序，从小到大加边，然后看1和n是否已经联通。怎么维护这个呢？不难想到用LCT进行link和cut操作。

        对于当前的边，我们判断它两端的点u和v是否已经联通，如果不联通就加上这条边，否则用access和Splay操作把u到v的原路径提取出来，同时Splay维护路径上的b最长的边的边权和编号，如果当前路径的b比原路径上b最长的边要短，那么可以知道当前路径更优，把原来b最长的那条边cut掉，然后link(u,v)。每次加边之后判断1和n是否联通，如果联通就记录1到n的路径上最长的b值和当前加边的a值为当前结果，对原有结果取min。

        由这个算法的过程可以知道，两点一旦联通就不会再分开，所以可以用普通并查集维护连通性。同时，边权的处理在LCT上很不方便，可以把边权改成点权，即原图上的点的点权为0，把边拆成一个新点和两条边，新点点权为原边权，这样可以方便很多，记得连接的时候要分别link这条边的两端点，cut边的时候也要记得cut掉该点的两条边。

代码：

#include<cstdio>
#include<algorithm>
using namespace std;

inline int read(){
	int xx=0,f=1;char ch=getchar();
	for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
	for(;ch>='0'&&ch<='9';ch=getchar())xx=xx*10+ch-'0';
	return xx*f;
}

const int maxn=50010,oo=0x7f7f7f7f;
struct edge{
	int a,b,from,to;
	bool operator<(edge x)const{
		return a<x.a;
	}
}e[maxn<<2];
struct node{
	int fa,ch[2],max,num,size,data;
	bool is_root,reverse;
}T[maxn<<3];
int n,m,f[maxn<<3];

int find(int x){
	if(f[x]!=x)f[x]=find(f[x]);
	return f[x];
}
void update(int x){
	T[x].size=1;T[x].max=T[x].data;T[x].num=x;
	if(T[x].ch[0]){
		T[x].size+=T[T[x].ch[0]].size;
		if(T[T[x].ch[0]].max>T[x].max)T[x].max=T[T[x].ch[0]].max,T[x].num=T[T[x].ch[0]].num;
	}
	if(T[x].ch[1]){
		T[x].size+=T[T[x].ch[1]].size;
		if(T[T[x].ch[1]].max>T[x].max)T[x].max=T[T[x].ch[1]].max,T[x].num=T[T[x].ch[1]].num;
	}
}
void pushreverse(int x){
	if(!x)return;
	swap(T[x].ch[0],T[x].ch[1]);
	T[x].reverse^=1;
}
void pushdown(int x){
	if(T[x].reverse){
		pushreverse(T[x].ch[0]);
		pushreverse(T[x].ch[1]);
		T[x].reverse=false;
	}
}
int getson(int x){
    return x==T[T[x].fa].ch[1];
}
void rotate(int x){
    if(T[x].is_root)return;
    int k=getson(x),fa=T[x].fa;
    int fafa=T[fa].fa;
    pushdown(fa);pushdown(x);
    T[fa].ch[k]=T[x].ch[k^1];
    if(T[x].ch[k^1])T[T[x].ch[k^1]].fa=fa;
    T[x].ch[k^1]=fa;
    T[fa].fa=x;
    T[x].fa=fafa;
    if(!T[fa].is_root)T[fafa].ch[fa==T[fafa].ch[1]]=x;
    else T[x].is_root=true,T[fa].is_root=false;
    update(fa);update(x);
}
void push(int x){
    if(!T[x].is_root)push(T[x].fa);
    pushdown(x);
}
void Splay(int x){
    push(x);
    for(int fa;!T[x].is_root;rotate(x)){
        if(!T[fa=T[x].fa].is_root){
            rotate((getson(x)==getson(fa))?fa:x);
        }
    }
}
void access(int x){
	int y=0;
	do{
		Splay(x);
		T[T[x].ch[1]].is_root=true;
		T[T[x].ch[1]=y].is_root=false;
		update(x);
		x=T[y=x].fa;
	}while(x);
}
void mroot(int x){
	access(x);
	Splay(x);
	pushreverse(x);
}
void link(int u,int v){
	mroot(u);
	T[u].fa=v;
	update(u);
}
void cut(int u,int v){
	mroot(u);
	Splay(v);
	T[T[v].ch[0]].fa=T[v].fa;
    T[T[v].ch[0]].is_root=true;
    update(T[v].ch[0]);
    T[v].fa=0;T[v].ch[0]=0;
}
void Init(){
	n=read();m=read();
	for(int i=1;i<=n+m;i++){
		T[i].fa=T[i].ch[0]=T[i].ch[1]=0;
		T[i].size=T[i].is_root=1;
		if(i<=n)T[i].max=T[i].data=0;
		f[i]=i;
	}
	for(int i=1;i<=m;i++){
		e[i].from=read();
		e[i].to=read();
		e[i].a=read();e[i].b=read();
	}
	sort(e+1,e+m+1);
	for(int i=1;i<=m;i++){
		T[i+n].data=T[i+n].max=e[i].b;
	}
}
void Work(){
	int ans=oo;
	for(int i=1;i<=m;i++){
		if(e[i].from==e[i].to)continue;
		if(find(e[i].from)!=find(e[i].to)){
			link(e[i].from,i+n);
			link(e[i].to,i+n);
			f[find(e[i].to)]=f[find(e[i].from)]=find(i+n);
		}
		else{
			mroot(e[i].from);
			access(e[i].to);
			Splay(e[i].to);
			int x=T[e[i].to].num;
			if(e[i].b<T[x].data){
				cut(e[i].from,x);cut(e[i].to,x);
				link(e[i].from,i+n);
				link(e[i].to,i+n);
			}
		}
		if(find(1)==find(n)){
			mroot(1);
			access(n);
			Splay(n);
			ans=min(ans,T[n].max+e[i].a);
		}
	}
	printf("%d\n",(ans==oo)?-1:ans);
}

int main(){
	Init();
	Work();
	return 0;
}