[UOJ#3][LOJ#2245]魔法森林(LCT)

题意

  给出一个 $n(n\le 50000)$ 个点 $m(m\le 100000)$ 条边的无向图，每条边有两个值 $a,b(a,b\le 50000)$ ，让你找出一条从 $1$ 到 $n$ 的路径使得经过的边的 $ma{x}_a+ma{x}_b$ 最小。

分析

  看到这题，它要求最大的最小，于是首先想到的是二分，就是二分 $ma{x}_a+ma{x}_b$ ，然后枚举 $a$ 的大小，这样可以知道 $b$ 的大小，每次跑dfs来check下就行了。不过我们发现这样的复杂度大概是 $O(n^2\log n)$ 的，无法通过此题。之后我们发现二分好像不太能在$O(n)$内check这个问题，于是弃掉二分转而去想其他做法。
  我们考虑对所有边以 $a$ 为关键字排序，然后一个一个加入图，维护一个关于 $b$ 的最小生成树，对于每次加入的一条边 $u,v$ ，如果它们原来不连通，那么就直接连上，不然找到 $u,v$ 上最大的 $b$ 的那条边，如果这条边的 $b$ 大于当前加入的这条边的 $b$ ，就将原来那条边删去，然后将这条边加入，然后每次查询 $1$ 到 $n$ 路径上最大的 $b$ 就行了。

Code

#pragma GCC optimize(3,"Ofast","inline")
#include
using namespace std;
typedef long long ll;
bool Finish_read;
template<class T>inline void read(T &x){Finish_read=0;x=0;int f=1;char ch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;if(ch==EOF)return;ch=getchar();}while(isdigit(ch))x=x*10+ch-'0',ch=getchar();x*=f;Finish_read=1;}
template<class T>inline void print(T x){if(x/10!=0)print(x/10);putchar(x%10+'0');}
template<class T>inline void writeln(T x){if(x<0)putchar('-');x=abs(x);print(x);putchar('\n');}
template<class T>inline void write(T x){if(x<0)putchar('-');x=abs(x);print(x);}
/*================Header Template==============*/
const int maxn=200005;
namespace LCT {
	struct Node {
		int ch[2],fa,val,pos,tag;
		inline void Clear() {
			ch[0]=ch[1]=fa=pos=val=tag=0;
		}
		inline int& operator [] (const int &x) {
			return this->ch[x];
		} 
	}T[maxn];
	inline void Reverse(int x) {
		if(x)
			swap(T[x][0],T[x][1]),T[x].tag^=1;
	}
	inline void Check(int x,int y) {
		if(!y)
			return;
		if(T[T[x].pos].val<T[T[y].pos].val)
			T[x].pos=T[y].pos;
	}
	inline void Pushup(int x) {
		T[x].pos=x,Check(x,T[x][0]),Check(x,T[x][1]);
	}
	inline void Pushdown(int x) {
		if(T[x].tag)
			Reverse(T[x][0]),Reverse(T[x][1]),T[x].tag=0;
	}
	inline int Isroot(int x) {
		return T[T[x].fa][0]!=x&&T[T[x].fa][1]!=x;
	}
	inline int Isright(int x) {
		return T[T[x].fa][1]==x; 
	}
	inline void Pushtag(int x) {
		if(!Isroot(x))
			Pushtag(T[x].fa);
		Pushdown(x);
	}
	inline void Rotate(int x) {
		int y=T[x].fa,z=T[y].fa,r=Isright(x),l=r^1;
		if(!Isroot(y))
			T[z][Isright(y)]=x;
		T[x].fa=z,T[y].fa=x,T[T[x][l]].fa=y,T[y][r]=T[x][l],T[x][l]=y,Pushup(y),Pushup(x);
	}
	inline void Splay(int x) {
		Pushtag(x);
		for(int y;!Isroot(x);Rotate(x))
			if(!Isroot(y=T[x].fa))
				Rotate(Isright(x)^Isright(y)?x:y);
	}
	inline void Access(int x) {
		for(int y=0;x;x=T[y=x].fa)
			Splay(x),T[x][1]=y,Pushup(x);
	}
	inline void Makeroot(int x) {
		Access(x),Splay(x),Reverse(x);
	}
	inline void Findpath(int x,int y) {
		Makeroot(x),Access(y),Splay(y);
	}
	inline int Findroot(int x) {
		Access(x),Splay(x);
		for(;T[x][0];x=T[x][0]);
		return Splay(x),x;
	}
	inline void Link(int x,int y) {
		Makeroot(x);
		if(Findroot(y)!=x)
			T[x].fa=y;
	}
	inline void Cut(int x,int y) {
		Makeroot(x);
		if(Findroot(y)!=x)
			return;
		Splay(y);
		if(T[y][0]!=x)
			return;
		T[x].fa=T[y][0]=0,Pushup(y);
	}
}
using LCT::T;
struct Edge {
	int u,v,a,b;
	inline bool operator < (const Edge &rhs) const {
		return a<rhs.a;
	}
	inline void Read() {
		read(u),read(v),read(a),read(b);
	}
}E[maxn];
int n,m,ans=1e9;
inline void Link(int x,int y,int z) {
	LCT::Makeroot(x),T[z].val=E[z-n].b;
	if(LCT::Findroot(y)!=x)
		LCT::Link(x,z),LCT::Link(y,z);
	else {
		LCT::Findpath(x,y);
		int p=T[y].pos;
		if(T[p].val>T[z].val)
			LCT::Cut(E[p-n].u,p),LCT::Cut(E[p-n].v,p),LCT::Link(z,x),LCT::Link(z,y);
	}
}
int main() {
	read(n),read(m);
	for(int i=1;i<=m;++i)
		E[i].Read();
	sort(E+1,E+m+1);
	for(int i=1;i<=m;++i) { 
		Link(E[i].u,E[i].v,i+n),LCT::Makeroot(1);
		if(LCT::Findroot(n)!=1)
			continue;
		LCT::Findpath(1,n),ans=min(ans,E[i].a+T[T[n].pos].val);
	} 
	printf("%d\n",ans==1e9?-1:ans);
}