UVa 12661 Funny Car Racing - spfa

---

　　很简单的一道最短路问题。分情况处理赛道的打开和关闭。

Code

 /**
  * UVa
  * Problem#12661
  * Accepted
  * Time:50ms
  */
 #include<iostream>
 #include<fstream>
 #include<sstream>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<ctime>
 #include<cctype>
 #include<cmath>
 #include<algorithm>
 #include<stack>
 #include<queue>
 #include<set>
 #include<map>
 #include<vector>
 using namespace std;
 typedef bool boolean;
 #define smin(a, b)    (a) = min((a), (b))
 #define smax(as, b)    (a) = max((a), (b))
 template<typename T>
 inline boolean readInteger(T& u){
     char x;
     int aFlag = ;
     while(!isdigit((x = getchar())) && x != '-' && x != -);
     if(x == -)    return false;
     if(x == '-'){
         x = getchar();
         aFlag = -;
     }
     for(u = x - ''; isdigit((x = getchar())); u = (u << ) + (u << ) + x - '');
     ungetc(x, stdin);
     u *= aFlag;
     return true;
 }

 typedef class Edge{
     public:
         int end;
         int next;
         int open;
         int close;
         int t;
         Edge(const int end = , const int next = , const int open = , const int close = , const int t = ):end(end), next(next), open(open), close(close), t(t){        }
         int across(int arrived){
             int re = arrived % (open + close);
             if(re >=  && re + t <= open)    return     arrived + t;
             return (arrived / (open + close) + ) * (open + close) + t;
         }
 }Edge;

 typedef class MapManager{
     public:
         int ce;
         Edge* edges;
         int* h;
         MapManager():ce(), edges(NULL), h(NULL){        }
         MapManager(int points, int limit):ce(){
             h = new int[(const int)(points + )];
             edges = new Edge[(const int)(limit + )];
             memset(h, , sizeof(int) * (points + ));
         }
         inline void addEdge(int from, int end, int open, int close, int t){
             if(t > open)    return;        //无法通过
             edges[++ce] = Edge(end, h[from], open, close, t);
             h[from] = ce;
         }
         Edge& operator [](int pos){
             return edges[pos];
         }
         void clear(){
             delete[] edges;
             delete[] h;
             ce = ;
         }
 }MapManager;

 #define m_begin(g, i)    (g).h[(i)]

 int n, m, from, _end;
 MapManager g;

 inline boolean init(){
     if(!readInteger(n))    return false;
     readInteger(m);
     readInteger(from);
     readInteger(_end);
     g = MapManager(n, m);
     for(int i = , u, v, a, b, t; i <= m; i++){
         readInteger(u);
         readInteger(v);
         readInteger(a);
         readInteger(b);
         readInteger(t);
         g.addEdge(u, v, a, b, t);
     }
     return true;
 }

 boolean* visited;
 queue<int>    que;
 int* f;
 inline int spfa(int s, int t){
     que.push(s);
     visited[s] = true;
     f[s] = ;
     while(!que.empty()){
         int e = que.front();
         que.pop();
         visited[e] = false;
         for(int i = m_begin(g, e); i != ; i = g[i].next){
             int& eu = g[i].end;
             int cmp = g[i].across(f[e]);
             if(cmp < f[eu]){
                 f[eu] = cmp;
                 if(!visited[eu] && eu != t){
                     que.push(eu);
                     visited[eu] = true;
                 }
             }
         }
     }
     return f[t];
 }

 inline void solve(){
     visited = new boolean[(const int)(n + )];
     f = new int[(const int)(n + )];
     memset(visited, false, sizeof(boolean) * (n + ));
     memset(f, 0x7f, sizeof(int) * (n + ));
     int res = spfa(from, _end);
     printf("%d\n", res);
 }

 inline void clear(){
     g.clear();
     delete[] visited;
     delete[] f;
 }

 int main(){
     int kase = ;
     while(init()){
         printf("Case %d: ", kase++);
         solve();
         clear();
     }
     return ;
 }