UVa 12661 - Funny Car Racing（Dijkstra）

链接：

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4399

题意：

在一个赛车比赛中，赛道有n（n≤300）个路口和m（m≤50000）条单向道路。有趣的是：每条路都是周期性关闭的。
每条路用5个整数u, v, a, b, t表示（1≤u,v≤n，1≤a,b,t≤1e5），表示起点是u，终点是v，通过时间为t秒。
另外，这条路会打开a秒，然后关闭b秒，然后再打开a秒，依此类推。当比赛开始时，每条道路刚刚打开。
你的赛车必须在道路打开的时候进入该道路，并且在它关闭之前离开（可以在打开的瞬间进入，关闭的瞬间离开）。
注意你的赛车可以在道路关闭的时候在路口等待它打开。没有道路连接同一个路口，但一对路口之间可能有多条道路。
你的任务是从s出发，尽早到达目的地t（1≤s,t≤n）。

分析：

本题是一道最短路问题，但又和普通的最短路问题不太相同：花费的总时间并不是经过的每条边的通过时间之和，
还要加上在每个点等待的总时间。仍然调用标准的Dijkstra算法，
只是在计算一个结点u出发的边权时要考虑d[u]（即从s出发达到u的最早时刻）。计算边权时分情况讨论一下即可。

代码：

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>
 using namespace std;

 struct Edge {
     int b, open, close, time;
 };
 struct HeapNode {
     int ver, dist;
     bool operator < (const HeapNode& that) const {
         return dist > that.dist;
     }
 };
 const int INF = 0x3f3f3f3f;
 const int UP =  + ;
 int d[UP];
 bool done[UP];
 vector<Edge> edge[UP];

 int Dijkstra(int start, int finish) {
     memset(d, INF, sizeof(d));
     memset(done, false, sizeof(done));
     d[start] = ;
     priority_queue<HeapNode> Q;
     Q.push((HeapNode){start, });
     while(!Q.empty()) {
         HeapNode f = Q.top();  Q.pop();
         int ver = f.ver;
         if(ver == finish) return f.dist;
         if(done[ver]) continue;
         done[ver] = true;
         for(int i = ; i < edge[ver].size(); i++) {
             Edge& b = edge[ver][i];
             int progress = d[ver] % (b.open + b.close);
             if(progress + b.time <= b.open) {
                 if(d[b.b] > d[ver] + b.time) {
                     d[b.b] = d[ver] + b.time;
                     Q.push((HeapNode){b.b, d[b.b]});
                 }
             } else {
                 int need = d[ver] + b.time + b.open + b.close - progress;
                 if(d[b.b] > need) {
                     d[b.b] = need;
                     Q.push((HeapNode){b.b, need});
                 }
             }
         }
     }
     return d[finish];
 }

 int main() {
     int n, m, start, finish;
     for(int cases = ; ~scanf("%d%d%d%d", &n, &m, &start, &finish); cases++) {
         for(int i = ; i <= n; i++) edge[i].clear();
         for(int L, R, a, b, t, i = ; i < m; i++) {
             scanf("%d%d%d%d%d", &L, &R, &a, &b, &t);
             if(t > a) continue;
             edge[L].push_back((Edge){R, a, b, t});
         }
         printf("Case %d: %d\n", cases, Dijkstra(start, finish));
     }
     return ;
 }