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. If it’s not possible to arrive at t from s (maybe your car is too slow!), print -1.

Samples

Input Copy

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

Output

Case 1: 20
Case 2: 9

题意：
n个路口，m条街道，每条街道都是有向的
并且这m条街道open a秒 close b秒（循环往复），自己的车通过这条道路需要t秒
可以从路口等待某一条道路open，必须在道路close 之前通过，且必须在另一条道路open的时候进入
问能否从s点到达t点，如果不能，输出-1,如果能输出最短的时间

细节的地方加在了代码里，在建图的过程中，如果说a > t，那么说这条路无论如何是走不过去的，所以干脆直接不建边

priority_queue<int, vector<int>, greater<int>> xiaogen;
priority_queue<int, vector<int>, less<int>> dagen;
const ll inf = 9223372036854775807;
const ll INF = 0x3f3f3f3f;
const int maxn = 3e5 + 7;
const int mod = 1000000007;
#define PI (double)acos(-1.0)
#define debug(x) cout << #x << "  ->  " << x << endl
#define IOS                      
    ios::sync_with_stdio(false); 
    cin.tie(NULL);               
    cout.tie(NULL);
#define lowbit(x) (x & (-x))
#define Clear(x, val) memset(x, val, sizeof x)
typedef pair<int, int> PII;
int cnt, head[maxn], n, m, s, t;
int dis[maxn], vis[maxn];
struct node {
    int u, v, a, b, t;
    int nex;
} e[maxn];
void add(int u, int v, int a, int b, int t) {
    e[cnt].u = u, e[cnt].v = v;
    e[cnt].a = a, e[cnt].b = b, e[cnt].t = t;
    e[cnt].nex = head[u];
    head[u] = cnt++;
}
void dij() {
    priority_queue<PII> que;
    Clear(dis, 0x3f3f3f3f);
    Clear(vis, false);
    dis[s] = 0;
    que.push({0, s});
    vis[s] = true;
    while (que.size()) {
        PII tp = que.top();
        que.pop();
        int u = tp.second;
        vis[u] = false; /// not in the queue
        for (int i = head[u]; ~i; i = e[i].nex) {
            int v = e[i].v;
            /**
            t1代表到达该点时，道路已经开放多长时间，如果已经开放的时间 + 通过需要的时间 <= 该周期总共开放的时间
            说明是可以通过的
            否则就需要等待该门重新开放，总共时间 = 等待时间 + 通过时间
            在该周期需要等待的时间 = a + b - t1
            通过需要的时间即为t
            所以总时间为 a + b - t1 + t
            **/
            int t1 = dis[u] % (e[i].a + e[i].b), t2;
            if (t1 + e[i].t <= e[i].a)
                t2 = e[i].t;
            else
                t2 = e[i].a + e[i].b + e[i].t - t1;
            if (dis[v] > dis[u] + t2) {
                dis[v] = dis[u] + t2;
                if (!vis[v])
                    que.push({dis[v], v});
            }
        }
    }
}
int main() {
	int _ = 0;
    while (cin >> n >> m >> s >> t) {
        Clear(head, -1);
        cnt = 0;
        for (int i = 1; i <= m; i++) {
            int u = read, v = read, a = read, b = read, t = read;
            if (a < t)
                continue;
            add(u, v, a, b, t);
        }
        dij();
        printf("Case %d: %d
", ++_, dis[t] == 0x3f3f3f3f ? -1 : dis[t]);
    }
    return 0;
}
/**


**/