UVA 12661（动态权值+最短路，dij）

题意：赛车背景，给你n个节点，m条边的图以及起点和终点；其中每条边的信息包括u（起点）,v（终点）,a（开启的时间）,b（关闭的时间）,d(通过这条道路的时间)；求最短通过的时间，其中车在进的时候，保证时间足够能走出去；否则需要等一些分钟；

思路：dij真是万能的，把固定权值改成动态的即可；

其中改变权值的语句很关键，并且推出的规律有个前提就是保证道路打开的时间一定大于等于通过该条道路的时间，否则相当于道路不通，被我忽略了，WA了3遍，可惜；

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <sstream>
 #include <queue>
 #include <vector>
 #define repu(i,a,b) for(int i=a;i<b;i++)
 using namespace std;
 #define N 330
 int v[N],t[N];
 const int maxn=;
 const int INF=0x3f3f3f3f;
 int rode[maxn];
 int c[N][N],p[N][N];
 int st = ,ed,k;
 struct Edge
 {
     int u,v,t1,t2,d;
     Edge(int u, int v, int t1,int t2, int d):u(u),v(v),t1(t1),t2(t2),d(d) {}
 };
 struct qnode
 {
     int u;
     int d;
     qnode(int u, int d):u(u), d(d) {}
     bool operator < (const qnode a)const
     {
         return d > a.d;
     }
 };

 int GetDist(int t, Edge e)
 {
     t %= (e.t1 + e.t2);
     if(e.d <= e.t1)///坑，一开始没加上
     {
         if(t >= e.t1 || e.t1 - t < e.d)
             return  e.t1 +e.t2 -t+e.d;
         else if(e.d + t <= e.t1)
             return  e.d;
     }
     return  INF;
 }
 struct Dijkstra
 {
     int n;
     vector<int> G[maxn];
     vector<Edge> edge;
     int d[maxn];
     bool vis[maxn];
     void init(int n)
     {
         this->n=n;
         for(int i=; i<=n; i++)
         {
             G[i].clear();
             vis[i]=;
             d[i]=INF;
         }
         edge.clear();
     }
     void AddEdge(int u, int v,int c,int e, int f)
     {
         G[u].push_back(edge.size());
         edge.push_back(Edge(u,v,c,e,f));
     }
     int dijkstra(int st,int ed)
     {
         int sum = ;
         memset(vis, , sizeof vis);
         repu(i,,n+)
         d[i] = INF;
         priority_queue<qnode> q;
         d[st]=;
         q.push(qnode(st, ));
         while(!q.empty())
         {
             qnode x=q.top();
             q.pop();
             if(vis[x.u])
                 continue ;
             vis[x.u]=true;
             if(x.u == ed)
                 return d[ed];
             for(int i=; i<G[x.u].size(); i++)
             {
                 Edge& e=edge[G[x.u][i]];
                 int vv = GetDist(d[x.u], e);///推这时候的权值
                 int tmp=d[x.u]+vv;///过这条边需要的时间
                 if(d[e.v] > tmp)
                 {
                     d[e.v]=tmp;
                     q.push(qnode(e.v, d[e.v]));
                 }
 ///                if(d[e.v] > d[x.u]+e.d)///原句
 ///                {
 ///                    d[e.v]=d[x.u]+e.d;
 ///                    q.push(qnode(e.v, d[e.v]));
 ///                }
             }
         }
         return d[ed];
     }
 } dij;
 int main()
 {
     int n,m,kase =;
     while(~scanf("%d%d%d%d",&m,&n,&st,&ed))
     {
         dij.init(m);
         memset(t,,sizeof(t));
         int a,b,f,c,e;
         repu(i,,n)
         {
             scanf("%d%d%d%d%d",&a,&b,&c,&e,&f);
             dij.AddEdge(a,b,c,e,f);
         }
         dij.dijkstra(st,ed);
         printf("Case %d: %d\n",kase++,dij.d[ed]);
     }
     return ;
 }