[NOI2014]魔法森林

題目描述

爲了獲得書法你們的真傳，小 E 同窗下定決心去拜訪住在魔法森林中的隱 士。魔法森林能夠被當作一個包含 n 個節點 m 條邊的無向圖，節點標號爲 1,2,3,…,n，邊標號爲 1,2,3,…,m。初始時小 E 同窗在 1 號節點，隱士則住在 n 號節點。小 E 須要經過這一片魔法森林，纔可以拜訪到隱士。

魔法森林中居住了一些妖怪。每當有人通過一條邊的時候，這條邊上的妖怪 就會對其發起攻擊。幸運的是，在 1 號節點住着兩種守護精靈：A 型守護精靈與 B 型守護精靈。小 E 能夠藉助它們的力量，達到本身的目的。

只要小 E 帶上足夠多的守護精靈，妖怪們就不會發起攻擊了。具體來講，無 向圖中的每一條邊 ei 包含兩個權值 ai 與 bi 。若身上攜帶的 A 型守護精靈個數不 少於 ai ，且 B 型守護精靈個數很多於 bi ，這條邊上的妖怪就不會對經過這條邊 的人發起攻擊。當且僅當經過這片魔法森林的過程當中沒有任意一條邊的妖怪向 小 E 發起攻擊，他才能成功找到隱士。

因爲攜帶守護精靈是一件很是麻煩的事，小 E 想要知道，要可以成功拜訪到 隱士，最少須要攜帶守護精靈的總個數。守護精靈的總個數爲 A 型守護精靈的 個數與 B 型守護精靈的個數之和。

輸入輸出格式

輸入格式：

輸入文件的第 1 行包含兩個整數 n,m，表示無向圖共有 n 個節點，m 條邊。 接下來 m 行，第i+ 1 行包含 4 個正整數 Xi,Yi,ai,bi，描述第i條無向邊。 其中Xi與 Yi爲該邊兩個端點的標號，ai 與 bi 的含義如題所述。 注意數據中可能包含重邊與自環。

輸出格式：

輸出一行一個整數：若是小 E 能夠成功拜訪到隱士，輸出小 E 最少須要攜 帶的守護精靈的總個數；若是不管如何小 E 都沒法拜訪到隱士，輸出「-1」（不 含引號）。

輸入輸出樣例

輸入樣例#1： 複製

4 5 
1 2 19 1 
2 3 8 12 
2 4 12 15 
1 3 17 8 
3 4 1 17 

輸出樣例#1： 複製

32

輸入樣例#2： 複製

3 1 
1 2 1 1 

輸出樣例#2： 複製

-1

說明

• 解釋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

題解：

每條邊有兩個權值，合在一塊兒維護十分不便，考慮將它們分開。

將全部邊按權值a從小到大排序，每一次加入一條邊，找一下1～n的全部路徑中權值b的最大值的最小值，而後用amax+bmax更新答案。

爲何這樣作是對的呢，若是bmax所在的路徑並非amax所在的路徑，那麼咱們在放入amax以前，bmax就已經和一個比amax要小的權值更新了答案，因此更優解已經被計算在內了。

而後每次SPFA不須要memset，直接將當前加入的邊的兩端點入隊就好。

這道題沒有設計卡SPFA的數據，因此SPFA能夠水過去。

 1 //Never forget why you start
 2 #include<iostream>
 3 #include<cstdio>
 4 #include<cstdlib>
 5 #include<cstring>
 6 #include<cmath>
 7 #include<algorithm>
 8 #include<queue>
 9 #define inf (2000000000)
10 using namespace std;
11 int n,m,ans=inf;
12 queue<int>mem;
13 struct Edge{
14   int from,to,dis1,dis2;
15 }e[100005];
16 struct node{
17   int next,to,dis1,dis2;
18 }edge[200005];
19 int head[50005],size;
20 void putin(int from,int to,int dis1,int dis2){
21   size++;
22   edge[size].next=head[from];
23   edge[size].to=to;
24   edge[size].dis1=dis1;
25   edge[size].dis2=dis2;
26   head[from]=size;
27 }
28 int dist[50005];
29 bool cmp(const Edge a,const Edge b){
30   return a.dis1<b.dis1;
31 }
32 int vis[50005];
33 void SPFA(int x,int y){
34   int i;
35   mem.push(x);mem.push(y);
36   vis[x]=vis[y]=1;
37   while(!mem.empty()){
38     int x=mem.front();mem.pop();
39     vis[x]=0;
40     for(i=head[x];i!=-1;i=edge[i].next){
41       int y=edge[i].to;
42       if(dist[y]>max(dist[x],edge[i].dis2)){
43     dist[y]=max(dist[x],edge[i].dis2);
44     if(!vis[y]){
45       mem.push(y);
46       vis[y]=1;
47     }
48       }
49     }
50   }
51 }
52 int main(){
53   int i,j;
54   scanf("%d%d",&n,&m);
55   memset(head,-1,sizeof(head));
56   for(i=1;i<=m;i++)
57     scanf("%d%d%d%d",&e[i].from,&e[i].to,&e[i].dis1,&e[i].dis2);
58   sort(e+1,e+m+1,cmp);
59   memset(dist,127/3,sizeof(dist));
60   mem.push(1);dist[1]=0;vis[0]=1;
61   for(i=1;i<=m;i++){
62     putin(e[i].from,e[i].to,e[i].dis1,e[i].dis2);
63     putin(e[i].to,e[i].from,e[i].dis1,e[i].dis2);
64     SPFA(e[i].from,e[i].to);
65     ans=min(ans,dist[n]+e[i].dis1);
66   }
67   if(ans==707406379)printf("-1\n");
68   else printf("%d\n",ans);
69   return 0;
70 }

可是SPFA的複雜度是沒法保證的，若是考場上要穩過的話就須要一個複雜度更加穩定的算法。

這題的正解是LCT，思惟難度仍是很高的，首先咱們將邊化爲點，若是一條邊鏈接x和y兩個點，咱們能夠認爲是一個點分別和x，y兩點相連。這樣咱們就能夠將權值信息放到中間那個點中。

而後仍是考慮排序，先按權值a排序，從小到大加邊，每次加一條邊，就至關因而link一下x，再link一下y。

每次判斷1和n是否聯通，若是聯通，就找路徑上的最大值更新答案就好。

若是咱們在鏈接的時候發現x和y是聯通的，若是咱們直接聯通就會產生環，那麼咱們考慮將這個環上最大的邊刪掉，由於一個環上最大的邊是沒有存在的意義的。（當咱們要通過這條最大的邊的時候，咱們能夠從環的另一邊繞過去）

注意：咱們要刪掉的是這個環上最大的邊，因此若是新加入的邊的權值比原路徑的最大值還要大，咱們就沒有必要加入了。（在這裏被坑了很久）

  1 //Never forget why you start
  2 #include<iostream>
  3 #include<cstdio>
  4 #include<cstdlib>
  5 #include<cstring>
  6 #include<cmath>
  7 #include<algorithm>
  8 #define ll(x) lct[x].child[0]
  9 #define rr(x) lct[x].child[1]
 10 #define son(x,t) lct[x].child[t]
 11 #define inf (2147483647)
 12 using namespace std;
 13 int n,m,ans=inf;
 14 int read(){
 15   int ans=0,f=1;char i=getchar();
 16   while(i<'0'||i>'9'){if(i=='-')f=-1;i=getchar();}
 17   while(i>='0'&&i<='9'){ans=ans*10+i-'0';i=getchar();}
 18   return ans*f;
 19 }
 20 struct Edge{
 21   int from,to,dis1,dis2,id;
 22   friend bool operator < (const Edge a,const Edge b){
 23     return a.dis1<b.dis1;
 24   }
 25 }e[100005];
 26 struct LCT{
 27   int child[2],fa,rev,x,mmax,size,pos;
 28   bool is_root;
 29 }lct[200005];
 30 void push_up(int x){
 31   lct[x].size=lct[ll(x)].size+lct[rr(x)].size+1;
 32   int mmax=lct[x].x,pos=x;
 33   if(lct[ll(x)].mmax>mmax)mmax=lct[ll(x)].mmax,pos=lct[ll(x)].pos;
 34   if(lct[rr(x)].mmax>mmax)mmax=lct[rr(x)].mmax,pos=lct[rr(x)].pos;
 35   lct[x].mmax=mmax;lct[x].pos=pos;
 36 }
 37 void push_rev(int x){
 38   if(!x)return;
 39   swap(ll(x),rr(x));
 40   lct[x].rev^=1;
 41 }
 42 void push_down(int x){
 43   if(lct[x].rev){
 44     push_rev(ll(x));
 45     push_rev(rr(x));
 46     lct[x].rev^=1;
 47   }
 48 }
 49 void push(int x){
 50   if(!lct[x].is_root)push(lct[x].fa);
 51   push_down(x);
 52 }
 53 int getson(int x){
 54   return x==son(lct[x].fa,1);
 55 }
 56 void rotate(int x){
 57   if(lct[x].is_root)return;
 58   int fa=lct[x].fa,fafa=lct[fa].fa,t=getson(x);
 59   son(fa,t)=son(x,!t);if(son(x,!t))lct[son(x,!t)].fa=fa;
 60   lct[fa].fa=x;son(x,!t)=fa;
 61   lct[x].fa=fafa;
 62   if(!lct[fa].is_root)son(fafa,son(fafa,1)==fa)=x;
 63   else lct[x].is_root=1,lct[fa].is_root=0;
 64   push_up(fa);
 65   push_up(x);
 66 }
 67 void splay(int x){
 68   push(x);
 69   for(int fa;!lct[x].is_root;rotate(x))
 70     if(!lct[fa=lct[x].fa].is_root)
 71       rotate(getson(x)==getson(fa)?fa:x);
 72 }
 73 void access(int x){
 74   int y=0;
 75   do{
 76     splay(x);
 77     lct[rr(x)].is_root=1;
 78     lct[rr(x)=y].is_root=0;
 79     push_up(x);
 80     x=lct[y=x].fa;
 81   }while(x);
 82 }
 83 void mroot(int x){
 84   access(x);
 85   splay(x);
 86   push_rev(x);
 87 }
 88 void link(int u,int v){
 89   mroot(u);
 90   lct[u].fa=v;
 91 }
 92 void cut(int u,int v){
 93   mroot(u);
 94   access(v);splay(v);
 95   lct[ll(v)].fa=lct[v].fa;
 96   lct[ll(v)].is_root=1;
 97   lct[v].fa=ll(v)=0;
 98   push_up(v);
 99 }
100 struct Fa{
101   int fa[200005],sum;
102   void clean(){
103     for(int i=1;i<=n+m;i++)
104       fa[i]=i;
105     sum=n+m;
106   }
107   int find(int x){
108     if(fa[x]==x)return x;
109     else return fa[x]=find(fa[x]);
110   }
111   void merge(int x,int y){
112     int p=find(x),q=find(y);
113     if(p!=q){
114       fa[p]=q;
115       sum--;
116     }
117   }
118   bool judge(int x,int y){
119     int p=find(x),q=find(y);
120     return p==q;
121   }
122 }fa;
123 int ppos[200005];
124 int main(){
125   int i,j;
126   n=read();m=read();
127   fa.clean();
128   for(i=1;i<=n;i++){
129     lct[i].child[0]=lct[i].child[1]=lct[i].fa=0;
130     lct[i].x=lct[i].mmax=0;
131     lct[i].size=lct[i].is_root=1;
132     lct[i].pos=i;
133   }
134   for(i=1;i<=m;i++){
135     e[i].from=read();e[i].to=read();e[i].dis1=read();e[i].id=i;e[i].dis2=lct[i+n].x=lct[i+n].mmax=read();
136     lct[i+n].child[0]=lct[i+n].child[1]=lct[i+n].fa=0;
137     lct[i+n].size=lct[i+n].is_root=1;
138     lct[i+n].pos=i;
139   }
140   sort(e+1,e+m+1);
141   for(i=1;i<=m;i++)ppos[e[i].id]=i;
142   for(i=1;i<=m;i++){
143     bool flag=0;
144     int u=e[i].from,v=e[i].to;
145     if(u==v)continue;
146     if(fa.judge(u,v)){
147       mroot(u);
148       access(v);
149       splay(v);
150       if(lct[v].mmax>lct[e[i].id+n].x){
151     flag=1;
152     int pos=lct[v].pos;
153     cut(pos,e[ppos[pos-n]].from);
154     cut(pos,e[ppos[pos-n]].to);
155       }
156     }
157     if(flag||!fa.judge(u,v)){
158       link(e[i].id+n,u);
159       link(e[i].id+n,v);
160       fa.merge(u,e[i].id+n);
161       fa.merge(e[i].id+n,v);
162     }
163     if(fa.judge(1,n)){
164       mroot(1);
165       access(n);
166       splay(n);
167       ans=min(ans,lct[n].mmax+e[i].dis1);
168     }
169   }
170   if(ans==inf)printf("-1\n");
171   else printf("%d\n",ans);
172   return 0;
173 }