文章标题 csu1333 :Funny Car Racing（最短路 spfa）

Funny Car Racing

Description

There is a funny car racing in a city with n junctions and m directed roads.

The funny part is: each road is open and closed periodically. Each road is associate with two integers (a, b), that means the road will be open for a seconds, then closed for b seconds, then open for a seconds… All these start from the beginning of the race. You must enter a road when it’s open, and leave it before it’s closed again.

Your goal is to drive from junction s and arrive at junction t as early as possible. Note that you can wait at a junction even if all its adjacent roads are closed.

Input

There will be at most 30 test cases. The first line of each case contains four integers n, m, s, t (1<=n<=300, 1<=m<=50,000, 1<=s,t<=n). Each of the next m lines contains five integers u, v, a, b, t (1<=u,v<=n, 1<=a,b,t<=105), that means there is a road starting from junction u ending with junction v. It’s open for a seconds, then closed for b seconds (and so on). The time needed to pass this road, by your car, is t. No road connects the same junction, but a pair of junctions could be connected by more than one road.

Output

For each test case, print the shortest time, in seconds. It’s always possible to arrive at t from s.

Sample Input

3 2 1 3

1 2 5 6 3

2 3 7 7 6

3 2 1 3

1 2 5 6 3

2 3 9 5 6

Sample Output

Case 1: 20

Case 2: 9

题意：给你n个点和m条边，每条边包含三个参数（开启的时间，关闭的时间和通过这条边的时间）的有向图，当你到达一个节点，如果剩余开启的时间不足够通过这条边，那么就得等下一个开放的期间，求从u到v的最短时间。

分析: 用spfa算法，当到达i节点时，我们可以确定前i-1的节点所用的时间为最优时间。

第一个例子：当从1-2时，用了3秒，接着从2-3时，开启剩余时间为（7-3%（7+7））=4<7，所以不能通过，所以得等下一个开启的时间，等待的时间为（4+7）=11；最后所用总时间为（3+11=6）=20。

代码：

#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<vector>
#include<math.h>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;
const int inf = 0x3f3f3f3f;
int n,m,s,t;
struct edge{
int v,a,b,time;
int nex;
};
edge e[50005];
int first[50005];
int tot;
void add(int u,int v,int a,int b,int time,int &k){
e[k].v=v, e[k].a=a, e[k].b=b, e[k].time=time, e[k].nex=first[u],first[u]=k++;
}
int flag[50005];
int dis[50005];//到达i所用的最短时间
void init(){
memset (first,-1,sizeof (first));
memset (flag,0,sizeof (flag));
tot=0;
}
int spfa(int s){//起点为s
queue<int>q;
memset (dis,inf,sizeof (dis));
flag[s]=1,dis[s]=0;
q.push(s);
while (!q.empty()){
int u=q.front() ;
q.pop() ;
flag[u]=0;
for (int i=first[u];i!=-1;i=e[i].nex){
int v=e[i].v;
int time_i=e[i].a + e[i].b;//第i条边的关闭和开启的一周期用的时间
//用（dis[u]%time_i) 求出到达第i条边时到达这条边的周期的那个时间点
//而ans表示开启的时间还剩多少，如果结果为负，说明此时在关闭期间
int ans=e[i].a - (dis[u]%time_i);
if (ans<e[i].time){
ans+=e[i].b;//如果剩下的时间不够通过就得等下一个周期，所以得加上关闭的时间b;
}
else ans=0;//如果时间够用
if (dis[v]>dis[u]+e[i].time+ans){
dis[v]=dis[u]+e[i].time+ans;//如果通过这条边的时间比之前用的时间短，就代替他
if(flag[v]==0){
flag[v]=1;
q.push(v);
}
}
}
}
return dis[t];
}
int main ()
{
int cnt=1;
while (scanf ("%d%d%d%d",&n,&m,&s,&t)!=EOF){
init();
int u,v,a,b,time;
for (int i=0;i<m;i++){
scanf ("%d%d%d%d%d",&u,&v,&a,&b,&time);
if (a>=time)//判断此条路能否保证通过
add(u,v,a,b,time,tot);
}
printf ("Case %d: %d\n",cnt++,spfa(s));
}
return 0;
}