[NOI2014]魔法森林

问题 G: [Noi2014]魔法森林

时间限制: 30 Sec  内存限制: 512 MB
提交: 18  解决: 9

题目描述

为了得到书法大家的真传,小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型守护精灵的个数之和。

输入

第1行包含两个整数N,M,表示无向图共有N个节点,M条边。 接下来M行,第行包含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

【输入样例2】
 
3 1
1 2 1 1

样例输出

【输出样例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。 

提示

2<=n<=50,000

0<=m<=100,000

1<=ai ,bi<=50,000

solution:

    这个题先要确定一个,再利用这个确定的最大值的最小值更行另一个。

    我先确定了a,把a记录一下,去重并从小到大排序,每次枚举a,并把和它长度一样的建边(一开始不建边),然后用b的值跑spfa,更新dis[n],dis表示从1到n的路径中b的最大值的最小值,ans=min(ans,dis[n]+当前枚举到的a的长度);

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<iostream>
 4 #include<algorithm>
 5 using namespace std;
 6 int read() {
 7     int s=0,f=1;
 8     char ch=getchar();
 9     while(ch<'0'||ch>'9') {
10         if(ch=='-') {
11             f=-1;
12         }
13         ch=getchar();
14     }
15     while(ch>='0'&&ch<='9') {
16         s=(s<<1)+(s<<3)+(ch^48);
17         ch=getchar();
18     }
19     return s*f;
20 }
21 int r[50005],tot,bian[100005],size;
22 struct edge {
23     int to,next,a,b;
24 } c[200005];
25 struct node {
26     int x,y,a,b;
27     friend bool operator < (node xx,node yy) {
28         return xx.a<yy.a;
29     }
30 } code[100005];
31 void add(int x,int y,int a,int b) {
32     c[tot]=(edge) {
33         y,r[x],a,b
34     };
35     r[x]=tot++;
36 }
37 int n,m,head,tail,queue[20000005],dis[50005];
38 bool flag[50005];
39 void spfa() {
40     while(head<tail) {
41         int u=queue[++head];
42         flag[u]=false;
43         for(int i=r[u]; ~i; i=c[i].next) {
44             if(dis[c[i].to]>max(dis[u],c[i].b)) {
45                 dis[c[i].to]=max(dis[u],c[i].b);
46                 if(!flag[c[i].to]) {
47                     flag[c[i].to]=true;
48                     queue[++tail]=c[i].to;
49                 }
50             }
51         }
52     }
53     return ;
54 }
55 int ans=0x7fffffff;
56 int main() {
57     n=read();
58     m=read();
59     memset(r,-1,sizeof(r));
60     memset(dis,0x6f,sizeof(dis));
61     for(int x,y,a,b,i=1; i<=m; i++) {
62         code[i]=(node) {
63             x=read(),y=read(),
64             a=read(),b=read()
65         };
66         bian[i]=a;
67     }
68     size=unique(bian+1,bian+m+1)-bian-1;
69     sort(bian+1,bian+size+1);
70     sort(code+1,code+m+1);
71     int i=1,j=1;
72     dis[1]=0;
73     for( ; i<=size; i++) {
74         head=tail=0;
75         for( ; j<=m; j++) {
76             if(bian[i]==code[j].a) {
77                 int x=code[j].x,y=code[j].y,a=code[j].a,b=code[j].b;
78                 add(x,y,a,b);
79                 add(y,x,a,b);
80                 queue[++tail]=x;
81                 queue[++tail]=y;
82                 flag[x]=flag[y]=true;
83             }
84             if(code[j].a>bian[i]) {
85                 break;
86             }
87         }
88         spfa();
89         ans=min(ans,dis[n]+bian[i]);
90     }
91     if(ans==1869574000){
92         cout<<"-1";
93         return 0;
94     }
95     cout<<ans;
96     return 0;
97 }

 

posted @ 2017-08-10 21:34  Forever_goodboy  阅读(355)  评论(0编辑  收藏  举报