H - Funny Car Racing

H - Funny Car Racing

Time Limit:1000MS     Memory Limit:0KB     64bit IO Format:%lld & %llu

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 Outpu

Case 1: 20

Case 2: 9

//这题的意思是：第一行4个整数 n,m,s,t . 1 < n < 300  , 1 < m < 50000 , 1 <= s , t <= n , n 是点的个数，m 是有向边的个数，s 是起点，t 是终点

第二行五个整数  u  , v  , a  , b  , t  ,说明有向边的起点，终点，这条边开启的时间，关闭的时间，通过需要的时间。这题简化了，通过这条边的条件是在关闭之前过去，不然就等到下个轮回再过去。显然t>a就不可能过去了，这数据应舍弃

//这题，是这个星期，完全没看别人的自己做出来的第一个题，对于刚学图论的有点难度。其实不难.

//spfa算法 0kb 50ms

 #include <cstdio>
 #include <cstring>
 #include <queue>
 using namespace std;
 
 #define MAXN 500005
 #define inf 0xfffffff
 
 struct Bian
 {
     int e;
     int a,b,t;
     int next;
 }bian[MAXN];
 
 int headlist[];
 int d[];
 int vis[];//其实我真不知道这个有什么用，不加也能过，有时候还能更快,但是每次看到spfa算法都加上我就加上了
 int Case=;
 
 int check(int time,Bian x)//通过这条边需要的时间
 {
     int k=time%(x.a+x.b);
     if (k+x.t<=x.a)
     {
         return x.t;
     }
     return x.a+x.b-k+x.t;
 }
 
 void spfa(int n,int m,int star,int end)
 {
     queue<int> Q;
     int i,x,v,y;
     for (i=;i<=n;i++)
     {
         d[i]=inf;
          vis[i]=;
      }
      d[star]=;
      Q.push(star);
      while (!Q.empty())
      {
          x=Q.front();
          Q.pop();
          vis[x]=;
          for (i=headlist[x];i!=-;i=bian[i].next)
          {
              v=bian[i].e;
              y=check(d[x],bian[i]);
              if (d[v]>d[x]+y)
              {
                  d[v]=d[x]+y;
                  if (!vis[v])
                  {
                      vis[v]=;
                      Q.push(v);
                 }
              }
         }
     }
     printf("Case %d: %d\n",++Case,d[end]);
 }
 
 int main()
 {
      int n,m,s,e;
      int u,v,a,b,t;
      int i;
      while (scanf("%d%d%d%d",&n,&m,&s,&e)!=EOF)
      {
          for (i=;i<=n;i++)
              headlist[i]=-;
 
          for (i=;i<=m;i++)
          {
              scanf("%d%d%d%d%d",&u,&v,&a,&b,&t);
              if (t>a) continue;
              bian[i].e=v;
              bian[i].a=a;
              bian[i].b=b;
              bian[i].t=t;
              bian[i].next=headlist[u];//这叫邻接表吧
              headlist[u]=i;
          }
          spfa(n,m,s,e);
      }
      return ;
 }