NOIP模拟赛 虫洞(holes)

Problem 3 虫洞(holes.cpp/c/pas)

【题目描述】

N个虫洞，M条单向跃迁路径。从一个虫洞沿跃迁路径到另一个虫洞需要消耗一定量的燃料和1单位时间。虫洞有白洞和黑洞之分。设一条跃迁路径两端的虫洞质量差为delta。

1.从白洞跃迁到黑洞，消耗的燃料值减少delta，若该条路径消耗的燃料值变为负数的话，取为0。

2.从黑洞跃迁到白洞，消耗的燃料值增加delta。

3.路径两端均为黑洞或白洞，消耗的燃料值不变化。

作为压轴题，自然不会是如此简单的最短路问题，所以每过1单位时间黑洞变为白洞，白洞变为黑洞。在飞行过程中，可以选择在一个虫洞停留1个单位时间，如果当前为白洞，则不消耗燃料，否则消耗s[i]的燃料。现在请你求出从虫洞1到N最少的燃料消耗，保证一定存在1到N的路线。

【输入格式】

第1行：2个正整数N,M

第2行：N个整数，第i个为0表示虫洞i开始时为白洞，1表示黑洞。

第3行：N个整数，第i个数表示虫洞i的质量w[i]。

第4行：N个整数，第i个数表示在虫洞i停留消耗的燃料s[i]。

第5..M+4行：每行3个整数，u,v,k，表示在没有影响的情况下，从虫洞u到虫洞v需要消耗燃料k。

【输出格式】

一个整数，表示最少的燃料消耗。

【样例输入】

4 5

1 0 1 0

10 10 100 10

5 20 15 10

1 2 30

2 3 40

1 3 20

1 4 200

3 4 200

【样例输出】

130

【数据范围】

对于30%的数据： 1<=N<=100,1<=M<=500

对于60%的数据： 1<=N<=1000,1<=M<=5000

对于100%的数据： 1<=N<=5000，1<=M<=30000

                  其中20%的数据为1<=N<=3000的链

                  1<=u,v<=N, 1<=k,w[i],s[i]<=200

【样例说明】

按照1->3->4的路线。

 

这道题乍一看是一道最短路，没错它就是一道最短路。

每一个洞都有两种情况（$黑点$或者$白点$），因为它可以变化。

那么根据题目所给的3种条件就可以重新对原图进行构图。

白洞到黑洞减少消耗，又因为没过一个单位时间就会变化，所以就连边两个白洞即可。

其余同理，跑一遍SPFA就行了。

  1 #include <queue>
  2 #include <cmath>
  3 #include <cstdio>
  4 #include <cstring>
  5 #include <algorithm>
  6 #define ll long long
  7 #define MAXN 10010
  8 #define MAXM 100010
  9  
 10 using namespace std;
 11  
 12 struct Node{
 13     int next;
 14     int to;
 15     int dis;
 16 } e[MAXM], edge[MAXM << 1];
 17  
 18 int he[MAXN], head[MAXN << 1], sum_edge;
 19 int mp[MAXN], w[MAXN], s[MAXN];
 20 int n, m;
 21  
 22 inline int readin()
 23 {
 24     int x = 0, f = 1;
 25     char c = getchar();
 26     while(!(c >= '0' && c <= '9')){if(c == '-') f = -1; c = getchar();}
 27     while(c >= '0' && c <= '9'){x = x * 10 + c - '0'; c = getchar();}
 28     return x * f;
 29 }
 30  
 31 void add_e(int from, int to, int dis)
 32 {
 33     e[++sum_edge].to = to;
 34     e[sum_edge].dis = dis;
 35     e[sum_edge].next = he[from];
 36     he[from] = sum_edge;
 37 }
 38 void add_edge(int from, int to, int dis)
 39 {
 40     edge[++sum_edge].to = to;
 41     edge[sum_edge].dis = dis;
 42     edge[sum_edge].next = head[from];
 43     head[from] = sum_edge;
 44 }
 45  
 46 void build(int x)
 47 {
 48     add_edge(x, x + n, s[x]);
 49     add_edge(x + n, x, 0);
 50     for(int i = he[x]; i; i = e[i].next)
 51     {
 52         int v = e[i].to;
 53         int weight = abs(w[x] - w[v]);
 54         if(mp[x] != mp[v])
 55         {
 56             add_edge(x, v, e[i].dis + weight);
 57             add_edge(x + n, v + n, max(0, e[i].dis - weight));
 58         }
 59         else
 60         {
 61             add_edge(x, v + n, e[i].dis);
 62             add_edge(x + n, v, e[i].dis);
 63         }
 64     }
 65 }
 66  
 67 int dis[MAXN << 1];
 68 bool mark[MAXN << 1];
 69 void SPFA()
 70 {
 71     memset(dis, 0x7f, sizeof dis);
 72      
 73     queue<int>Q;
 74      
 75     if(mp[1]) {Q.push(1); dis[1] = 0;}
 76     else {Q.push(1 + n); dis[1 + n] = 0;}
 77      
 78     while(!Q.empty())
 79     {
 80         int u = Q.front();
 81         Q.pop();
 82         mark[u] = false;
 83         for(int i = head[u]; i; i = edge[i].next)
 84         {
 85             int v = edge[i].to;
 86             if(dis[v] > dis[u] + edge[i].dis)
 87             {
 88                 dis[v] = dis[u] + edge[i].dis;
 89                 if(!mark[v])
 90                 {
 91                     Q.push(v);
 92                     mark[v] = true;
 93                 }
 94             }
 95         }
 96     }
 97     printf("%d\n", min(dis[n], dis[n * 2]));
 98 }
 99  
100 int main()
101 {
102     n = readin(), m = readin();
103     for(int i = 1; i <= n; i++) mp[i] = readin();
104     for(int i = 1; i <= n; i++) w[i] = readin();
105     for(int i = 1; i <= n; i++) s[i] = readin();
106     for(int i = 1; i <= m; i++)
107     {
108         int x, y, z;
109         x = readin(), y = readin(), z = readin();
110         add_e(x, y, z);
111     }
112      
113     sum_edge = 0;
114     for(int i = 1; i <= n; i++) build(i);
115     SPFA();
116     return 0;
117 }

 

转载于:https://www.cnblogs.com/Y-sofun/p/7502109.html