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 = 1;
while(!isdigit((x = getchar())) && x != '-' && x != -1);
if(x == -1)    return false;
if(x == '-'){
x = getchar();
aFlag = -1;
}
for(u = x - '0'; isdigit((x = getchar())); u = (u << 3) + (u << 1) + x - '0');
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 = 0, const int next = 0, const int open = 0, const int close = 0, const int t = 0):end(end), next(next), open(open), close(close), t(t){        }
int across(int arrived){
int re = arrived % (open + close);
if(re >= 0 && re + t <= open)    return     arrived + t;
return (arrived / (open + close) + 1) * (open + close) + t;
}
}Edge;

typedef class MapManager{
public:
int ce;
Edge* edges;
int* h;
MapManager():ce(0), edges(NULL), h(NULL){        }
MapManager(int points, int limit):ce(0){
h = new int[(const int)(points + 1)];
edges = new Edge[(const int)(limit + 1)];
memset(h, 0, sizeof(int) * (points + 1));
}
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 = 0;
}
}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 = 1, 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] = 0;
while(!que.empty()){
int e = que.front();
que.pop();
visited[e] = false;
for(int i = m_begin(g, e); i != 0; 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 + 1)];
f = new int[(const int)(n + 1)];
memset(visited, false, sizeof(boolean) * (n + 1));
memset(f, 0x7f, sizeof(int) * (n + 1));
int res = spfa(from, _end);
printf("%d\n", res);
}

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

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