bsoj 4195 【NOI2014】魔法森林

4195 -- 【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 51 2 19 12 3 8 122 4 12 151 3 17 83 4 1 17【输入样例2】3 11 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

动态最小生成树

用LCT维护

据说SPFA可以过

没去试。。。

思路大致是一样的

先对第一种属性排序，

然后枚举每一条边，

如果这条边的两个端点连通的话就取出这两个端点所在路的最大的第二属性与这条边比较，

如果这条边权值小的话就删去最大的边，再连接这条，

如果没连通就直接连接这条边。

这样的话每次加边后用并查集判断1和n是否连通

连通就取一次最小值。。

PS :   注意把边权变成点

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
int n,m;
struct LCT{	
	int l;
	int r;
	int OnPath;
	int fa;
	int data;
	int Max;
	int rev;
}Tree[1000000];
void update(int x){
	Tree[x].Max=x;
	if(Tree[x].l&&Tree[Tree[x].Max].data<Tree[Tree[Tree[x].l].Max].data)Tree[x].Max=Tree[Tree[x].l].Max;
	if(Tree[x].r&&Tree[Tree[x].Max].data<Tree[Tree[Tree[x].r].Max].data)Tree[x].Max=Tree[Tree[x].r].Max;
}
void pushdown(int x){
	if(Tree[x].rev){
		Tree[Tree[x].l].rev^=1;
		Tree[Tree[x].r].rev^=1;
		swap(Tree[x].l,Tree[x].r);
		Tree[x].rev=0;
	}
}
void Rotate(int x){
	int y=Tree[x].fa;
	int z=Tree[y].fa;
	if(Tree[y].l==x){
		Tree[y].l=Tree[x].r;
		Tree[Tree[x].r].fa=y;	
		Tree[x].r=y;
		if(Tree[y].OnPath){
		if(Tree[z].l==y)Tree[z].l=x;
		if(Tree[z].r==y)Tree[z].r=x;
		}
		Tree[y].fa=x;
		Tree[x].fa=z;
		if(!Tree[y].OnPath){
			Tree[y].OnPath=1;
			Tree[x].OnPath=0;
		}
	}
	else if(Tree[y].r==x){
		Tree[y].r=Tree[x].l;
		Tree[Tree[x].l].fa=y;
		Tree[x].l=y;
		if(Tree[y].OnPath){
		if(Tree[z].l==y)Tree[z].l=x;
		if(Tree[z].r==y)Tree[z].r=x;
		}
		Tree[y].fa=x;
		Tree[x].fa=z;
		if(!Tree[y].OnPath){
			Tree[y].OnPath=1;
			Tree[x].OnPath=0;
		}
	}
	update(y);
}
void Splay(int x){
	pushdown(x);
	while(Tree[x].OnPath){
		int y=Tree[x].fa;
		int z=Tree[y].fa;
		if(Tree[y].OnPath)
		pushdown(z);
		pushdown(y);
		pushdown(x);
		if(!Tree[y].OnPath){
			Rotate(x);
			break;
		}
		if((Tree[z].l==y)==(Tree[y].l==x)){
			Rotate(y);
			Rotate(x);
		}
		else {
			Rotate(x);
			Rotate(x);
		}
	}
	update(x);
}
void Access(int u){
	int v=0;
	while(u){
		Splay(u);
		Tree[Tree[u].r].OnPath=0;
		Tree[u].r=v;
		Tree[v].OnPath=1;
		v=u;
		u=Tree[u].fa;
		update(v);
	}
}
void Make_Root(int x){
	Access(x);
	Splay(x);
	Tree[x].rev^=1;
}
void link(int x,int y){
	Make_Root(x);
	Tree[x].fa=y;
}
void cut(int x,int y){
	Make_Root(x);
	Access(y);
	Splay(y);
	Tree[Tree[y].l].fa=0;
	Tree[Tree[y].l].OnPath=0;
	Tree[y].l=0;
	update(y);
}
int query(int x,int y){
	Make_Root(x);
	Access(y);
	Splay(y);
	return Tree[y].Max;
} 
int father[5000005];
struct Edge{
	int x,y,a,b;
}w[500005];
bool cmp(Edge e1,Edge e2){
	return e1.a<e2.a;
}
int getf(int k){
	if(father[k]==k)return k;
	else return father[k]=getf(father[k]);
}
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;
}
int main(){
	n=read();
	m=read();
	for(int i=1;i<=m;i++){
		w[i].x=read();
		w[i].y=read();
		w[i].a=read();
		w[i].b=read();
	}
	sort(w+1,w+m+1,cmp);
	for(int i=1;i<=n;i++)father[i]=i;
	int cnt=1;
	int ans=0x7fffffff;
	for(int i=1;i<=m;i++){
		int x=w[i].x,y=w[i].y,a=w[i].a,b=w[i].b;
		if(getf(x)==getf(y)){
			int v=query(x,y);
			if(Tree[v].data>b){
				cut(v,w[v-n].x);
				cut(v,w[v-n].y);
			}
			else {
				continue;
			}
		}
		else 
		father[getf(x)]=getf(y);
		Tree[i+n].data=b;
		Tree[i+n].Max=cnt+n;
		link(x,i+n);
		link(i+n,y);
		if(getf(1)==getf(n)){
			ans=min(ans,Tree[query(1,n)].data+a);
		}
	}
	if(ans!=0x7fffffff)cout<<ans;
	else cout<<"-1";
	return 0;
}