图论 BZOJ 3669 [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。

 

 

　　这题对A排序，然后加边，用LCT维护树的连通性。

 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <cstdio>
 using namespace std;
 const int maxn=;
 const int maxm=;

 int A[maxm],B[maxm],U[maxm],V[maxm],P[maxm];
 int fa[maxn+maxm],ch[maxn+maxm][],Max[maxm+maxn],Mpos[maxn+maxm],key[maxn+maxm],flip[maxn+maxm];
 int f[maxn];
 bool rt[maxn+maxm];

 void Flip(int p){
     if(!p)return;
     swap(ch[p][],ch[p][]);
     flip[p]^=;
 }

 void Push_down(int p){
     if(flip[p]){
         Flip(ch[p][]);
         Flip(ch[p][]);
         flip[p]=;
     }
 }

 void Push_up(int p){
     Max[p]=max(key[p],max(Max[ch[p][]],Max[ch[p][]]));
     if(Max[p]==key[p])
         Mpos[p]=p;
     else if(Max[p]==Max[ch[p][]])
         Mpos[p]=Mpos[ch[p][]];
     else if(Max[p]==Max[ch[p][]])
         Mpos[p]=Mpos[ch[p][]];
 }

 void Pd(int p){
     if(!rt[p])Pd(fa[p]);
     Push_down(p);
 }

 void Rotate(int x){
     int y=fa[x],g=fa[y],c=ch[y][]==x;
     ch[y][c]=ch[x][c^];
     ch[x][c^]=y;
     fa[y]=x;fa[ch[y][c]]=y;
     fa[x]=g;
     if(rt[y])
         rt[y]=false,rt[x]=true;
     else
         ch[g][ch[g][]==y]=x;
     Push_up(y);
 }

 void Splay(int x){
     Pd(x);
     for(int y=fa[x];!rt[x];Rotate(x),y=fa[x])
         if(!rt[y])
             Rotate((ch[fa[y]][]==y)==(ch[y][]==x)?y:x);
     Push_up(x);
 }

 void Access(int x){
     int y=;
     while(x){

         Splay(x);

         rt[ch[x][]]=true;
         rt[ch[x][]=y]=false;
         Push_up(x);
         x=fa[y=x];
     }
 }

 void Make_root(int x){
     Access(x);
     Splay(x);
     Flip(x);
 }

 void Link(int x,int y){
     Make_root(x);
     fa[x]=y;
 }
 void Cut(int x,int y){
     Make_root(x);
     Splay(y);
     fa[ch[y][]]=fa[y];
     rt[ch[y][]]=true;
     fa[y]=;ch[y][]=;
     Push_up(y);
 }

 void Lca(int &x,int &y){
     Access(y);y=;
     while(true){
         Splay(x);
         if(!fa[x])return;
         rt[ch[x][]]=true;
         rt[ch[x][]=y]=false;
         Push_up(x);
         x=fa[y=x];
     }
 }

 int Query(int x,int y){
     Lca(x,y);
     int ret=max(key[x],max(Max[ch[x][]],Max[y]));
     if(ret==key[x])
         return x;
     else if(ret==Max[ch[x][]])
         return Mpos[ch[x][]];
     return Mpos[y];
 }

 int find(int x){
     return f[x]==x?x:f[x]=find(f[x]);
 }

 bool cmp(int a,int b){
     return A[a]<A[b];
 }

 int main(){
     int n,m,S,T,ans;
     scanf("%d%d",&n,&m);
     for(int i=;i<=m;P[i]=i,i++)
         scanf("%d%d%d%d",&U[i],&V[i],&A[i],&B[i]);
     for(int i=;i<=n+m;i++)rt[i]=true;
     for(int i=;i<=n;i++)f[i]=i;
     sort(P+,P+m+,cmp);
     S=,T=n;
     ans=;
     for(int i=;i<=m;i++){
         Max[n+P[i]]=key[n+P[i]]=B[P[i]];

         if(find(U[P[i]])!=find(V[P[i]])){
             Link(U[P[i]],n+P[i]);
             Link(V[P[i]],n+P[i]);
             f[find(U[P[i]])]=find(V[P[i]]);
         }
         else{
             int p=Query(U[P[i]],V[P[i]]);
             if(B[p-n]>B[P[i]]){
                 Cut(U[p-n],p);
                 Cut(V[p-n],p);
                 Link(U[P[i]],P[i]+n);
                 Link(V[P[i]],P[i]+n);
             }
             else
                 continue;
         }
         if(find(S)==find(T))
             ans=min(ans,A[P[i]]+B[Query(S,T)-n]);
     }
     printf("%d\n",(ans==)?-:ans);
 }