bzoj3669: [Noi2014]魔法森林

地址：

题目：

3669: [Noi2014]魔法森林

Time Limit: 30 Sec Memory Limit: 512 MB
Submit: 2955 Solved: 1851
[Submit][Status][Discuss]

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

思路：

　　二维mst？

　　考虑先把边按第一关键字为ai，第二关键字为bi排序，然后依次加边。

　　如果成环了，就删掉环上bi最大的边。

  1 /**************************************************************
  2     Problem: 3669
  3     User: weeping
  4     Language: C++
  5     Result: Accepted
  6     Time:6500 ms
  7     Memory:48200 kb
  8 ****************************************************************/
  9  
 10 #include <bits/stdc++.h>
 11  
 12 using namespace std;
 13  
 14 struct node
 15 {
 16     int u,v,a,b;
 17     node(){}
 18     node(int x,int y,int z,int w){u=x,v=y,a=z,b=w;}
 19     bool operator < (const node &ta) const
 20     {
 21         return a < ta.a || ( a == ta.a && b < ta.b);
 22     }
 23 }eg[1000005];
 24  
 25 struct Link_Cut_Tree
 26 {
 27     static const int MAXN = 1000000 + 7;
 28  
 29     int ch[MAXN][2], fa[MAXN], rev[MAXN], v[MAXN], mx[MAXN], id[MAXN];
 30     int sk[MAXN];
 31  
 32     bool isroot(int x)
 33     {
 34         return ch[fa[x]][0] != x && ch[fa[x]][1] != x;
 35     }
 36  
 37     void reverse(int x)
 38     {
 39         rev[x] ^= 1, swap(ch[x][0],ch[x][1]);
 40     }
 41  
 42     void update(int x)
 43     {
 44         int lc = ch[x][0],rc = ch[x][1];
 45         mx[x] = v[x], id[x] = x;
 46         if(lc && mx[lc] > mx[x])
 47             mx[x] = mx[lc], id[x] = id[lc];
 48         if(rc && mx[rc] > mx[x])
 49             mx[x] = mx[rc], id[x] = id[rc];
 50     }
 51  
 52     void push_down(int x)
 53     {
 54         if(!rev[x]) return ;
 55         if(ch[x][0]) reverse(ch[x][0]);
 56         if(ch[x][1]) reverse(ch[x][1]);
 57         rev[x]=0;
 58     }
 59  
 60     void rotate(int x)
 61     {
 62         int f = fa[x], gf = fa[f];
 63         int t1 = ( x != ch[f][0]), t2 = ( f != ch[gf][0]), tmp = ch[x][1^t1];
 64         if(!isroot(f)) ch[gf][0^t2] = x;
 65         fa[tmp] = f, fa[x] = gf, ch[x][1^t1] = f, fa[f] = x, ch[f][0^t1] = tmp;
 66         update(f);
 67     }
 68  
 69     void splay(int x)
 70     {
 71         int top = 0;
 72         sk[++top] = x;
 73         for(int i = x; !isroot(i); i = fa[i])   sk[++top] = fa[i];
 74         while(top)  push_down(sk[top--]);
 75         for(int f = fa[x], gf = fa[f]; !isroot(x); rotate(x), f = fa[x],gf = fa[f])
 76         if(!isroot(f))
 77             rotate((x==ch[f][0]) ^ (f==ch[gf][0]) ? x : f);
 78         update(x);
 79     }
 80  
 81     void access(int x)
 82     {
 83         for(int p = 0; x; p = x, x = fa[x])
 84             splay(x), ch[x][1] = p, update(x);
 85     }
 86  
 87     void makeroot(int x)
 88     {
 89         access(x), splay(x), reverse(x);
 90     }
 91  
 92     int findroot(int x)
 93     {
 94         access(x), splay(x);
 95         while(ch[x][0]) x = ch[x][0];
 96         return x;
 97     }
 98     void link(int x,int y)
 99     {
100         makeroot(x), fa[x] = y;
101     }
102  
103     void cut(int x,int y)
104     {
105         makeroot(x), access(y), splay(y);
106         if(ch[y][0] == x)   ch[y][0] = fa[x] = 0;
107         update(y);
108     }
109  
110     void go(int n,int m)
111     {
112         int ans=1e9;
113         sort(eg+1,eg+1+m);
114         for(int i=1;i<=m;i++)
115         {
116             int tu=eg[i].u,tv=eg[i].v,bi=eg[i].b,p=i+n;
117             v[p]=mx[p]=bi,id[p]=p;
118             if(tu==tv)  continue;
119             if(findroot(tu)!=findroot(tv))
120                 link(tu,p),link(p,tv);
121             else
122             {
123                 makeroot(tu),access(tv),splay(tv);
124                 if(mx[tv] > bi)
125                 {
126                     int q=id[tv]-n;
127                     cut(eg[q].u,q+n),cut(eg[q].v,q+n);
128                     link(tu,p),link(p,tv);
129                 }
130             }
131             if(findroot(1)==findroot(n))
132             {
133                 makeroot(1),access(n),splay(n);
134                 ans=min(ans,eg[i].a+mx[n]);
135             }
136         }
137         if(ans==(int)1e9)
138             printf("-1
");
139         else
140             printf("%d
",ans);
141     }
142 }lct;
143  
144 int main(void)
145 {
146     //freopen("in.acm","r",stdin);
147     int n,m;
148     scanf("%d%d",&n,&m);
149     for(int i=1;i<=n;i++) lct.v[i]=-1;
150     for(int i=1,x,y,a,b;i<=m;i++)
151         scanf("%d%d%d%d",&x,&y,&a,&b),eg[i] = node(x,y,a,b);
152     lct.go(n,m);
153     return 0;
154 }