有趣的赛车比赛uva12661最短路

题意：

有n个城市，m条边，问你从城市s到tt的总时间。每条路都有开放时间和关闭时间，还给出了你通过那条路的时间，你必须在那条路开放的时间内通过那条路，不然的话就只能等待那条再次开放然后通过，开关的计时是在从城市s出发开始的。

思路：

算出当前时间，路径距离关闭还剩下的时间，如果大于t，那么可以通过，否则，只能等到下一次。
如果下一次也不能通过，即t>a，输入的时候忽略这些边。
求耗费时有点不同，其余用Dijkstra就好了。

#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
#include <algorithm>
#define fi first
#define se second
#define pii pair<int,int>
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
const int maxn = 300+5;
LL d[maxn], done[maxn];

// 图
struct Edge{
	int u,v,a,b,t;
	Edge(int a, int b, int c, int d, int e):u(a),v(b),a(c),b(d),t(e){}
}; 
vector<Edge> edges;
vector<int> G[maxn];

void init(){
	for(int i = 0; i < maxn; ++i) G[i].clear();
	edges.clear();
}
void addEdge(int u, int v, int a, int b, int t){
	edges.push_back(Edge(u,v,a,b,t));
	int m = edges.size();
	G[u].push_back(m-1);
}

int cost(int cur_time, Edge& e){
	int r = cur_time%(e.a + e.b);
	if(r + e.t <= e.a) return e.t;
	return e.a + e.b - r + e.t;
}
struct Node{
	int u; // 顶点u，到达u最早的时刻 
	LL t;
	Node(int a, LL b):u(a),t(b){}
	bool operator<(const Node& rhs)const{
		return t > rhs.t;
	}
};
int Dijkstra(int s, int t){
	memset(done, 0, sizeof(done));
	for(int i = 0; i < maxn; ++i) d[i] = INF;
	d[s] = 0;
	priority_queue<Node> Q;
	Q.push(Node(s,0));
	while(!Q.empty()){
		Node x = Q.top(); Q.pop();
		int u = x.u;
		if(u == t) return d[t];
		if(done[u]) continue;
		done[u] = 1;
		for(int i = 0; i < G[u].size(); ++i){
			Edge e = edges[G[u][i]];
			int c = cost(d[u], e);
			if(d[e.v] > d[u] + c){
				d[e.v] = d[u] + c;
				Q.push(Node(e.v, d[e.v]));
			}
		}
	} 
	return -1;
}

int main()
{
	freopen("in.txt","r",stdin);
	int n,m,s,t;
	int kase = 1;
	while(scanf("%d%d%d%d",&n,&m,&s,&t) == 4&&n){
		init();
		int u,v,a,b,c;
		for(int i = 0; i < m; ++i){
			scanf("%d%d%d%d%d",&u,&v,&a,&b,&c);
			if(c > a) continue;
			addEdge(u,v,a,b,c);
		}
		int ans = Dijkstra(s, t);
		printf("Case %d: %d\n", kase++, ans);
	}

	return 0;
}