BZOJ3669[NOI2014] 魔法森林

原题链接：https://www.lydsy.com/JudgeOnline/problem.php?id=3669

魔法森林

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

题解

我们先按照$a$排序，动态维护最小生成树，当出现环的时候，就把环上$b$值最大的那条边删去。这样，当前方案的代价就是当前加入的边的$a$值加上$1\to n$路径上$b$的最大值。

值得一提的是，因为在维护最小生成树的时候是不会改变结点之间的连通性的，所以我们可以用并查集来维护联通块，就能避免每次调用$findroot$。

代码

#include<bits/stdc++.h>
#define ls son[v][0]
#define rs son[v][1]
using namespace std;
const int M=2e5+5;
int n,m,sta[M],dad[M],mx[M],son[M][2],val[M],fa[M],r;
bool rev[M];
char c;
struct sd{int f,t,a,b;};
sd edge[M];
inline char nc()
{
	static const int buflen=2e6;
	static char buf[buflen],*p1=buf,*p2=buf;
	return p1==p2&&(p2=(p1=buf)+fread(buf,1,buflen,stdin),p1==p2)?EOF:*p1++;
}
int read()
{
	r=0;
	while(!isdigit(c))c=nc();
	while(isdigit(c)){r=(r<<1)+(r<<3)+c-'0',c=nc();}
	return r;
}
bool operator <(sd a,sd b){return a.a<b.a;}
bool notroot(int v){return son[dad[v]][0]==v||son[dad[v]][1]==v;}
void up(int v){mx[v]=v;if(val[mx[ls]]>val[mx[v]])mx[v]=mx[ls];if(val[mx[rs]]>val[mx[v]])mx[v]=mx[rs];}
void turn(int v){swap(ls,rs);rev[v]^=1;}
void push(int v){if(!rev[v])return;if(ls)turn(ls);if(rs)turn(rs);rev[v]=0;}
void spin(int v)
{
	int f=dad[v],ff=dad[f],k=son[f][1]==v,w=son[v][!k];
	if(notroot(f))son[ff][son[ff][1]==f]=v;
	son[v][!k]=f;son[f][k]=w;
	if(w)dad[w]=f;
	dad[f]=v;dad[v]=ff;
	up(f);up(v);
}
void splay(int v)
{
	int f,ff,top=0,u=v;
	sta[++top]=u;
	while(u)sta[++top]=u=dad[u];
	while(top)push(sta[top--]);
	while(notroot(v))
	{
		f=dad[v];ff=dad[f];
		if(notroot(f))spin((son[f][0]==v)^(son[ff][0]==f)?v:f);
		spin(v);
	}
}
void access(int v){for(int f=0;v;v=dad[f=v])splay(v),rs=f,up(v);}
void beroot(int v){access(v);splay(v);turn(v);}
void link(int x,int y){beroot(x);dad[x]=y;}
void cut(int x,int y){beroot(x);access(y);splay(y);dad[x]=son[y][0]=0;up(y);}
int ques(int x,int y){beroot(x);access(y);splay(y);return mx[y];}
int find(int v){return fa[v]==v?v:fa[v]=find(fa[v]);}
void in()
{
	n=read();m=read();
	for(int i=1;i<=n;++i)fa[i]=i;
	for(int i=1;i<=m;++i)
	edge[i].f=read(),edge[i].t=read(),edge[i].a=read(),edge[i].b=read();
}
void ac()
{
	sort(edge+1,edge+1+m);
	int f,t,a,b,x,ans=1e9;
	for(int i=1;i<=m;++i)
	{
		f=edge[i].f;t=edge[i].t;a=edge[i].a;b=edge[i].b;
		if(find(f)==find(t))
		{
			x=ques(f,t);
			if(val[x]>b)cut(x,edge[x-n].f),cut(x,edge[x-n].t);
			else{if(find(1)==find(n))ans=min(ans,val[ques(1,n)]+edge[i].a);continue;}
		}
		else fa[find(f)]=find(t);
		val[n+i]=b;mx[n+i]=n+i;
		link(f,n+i);link(t,n+i);
		if(find(1)==find(n))ans=min(ans,val[ques(1,n)]+edge[i].a);
	}
	if(ans>=9e8)printf("-1");
	else printf("%d",ans);
}
int main()
{
	in();ac();
	return 0;
}