[题解]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
.max+e[i].a);
}
}
printf("%d\n",(ans==oo)?-1:ans);
}

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