POJ 3594 Escort of Dr. Who How【最短路径Dij + 枚举】

POJ 3594 Escort of Dr. Who How【最短路径Dij + 枚举】http://poj.org/problem?id=3594

Escort of Dr. Who How Time Limit: 2000MS   Memory Limit: 131072K Total Submissions: 2117   Accepted: 504 Description The notorious ringleader and cyber-criminal Derek Wu, better known as Dr. Who How, has been convicted for multiple abductions and cyber-frauds several minutes ago. He will soon be transferred from the court to the prison to serve a life sentence. Intelligence from undercover officers in Dr. Who How’s outlawed gang indicates a possible forcible rescue operation by gang members in the case that Dr. Who How is convicted. To ensure a successful escort, besides adopting enhanced security measures, the police force further desires to minimize the escort time—the time that the motorcade of escort has to spend between departure from the court and arrival at the prison. The complex traffic condition in the city imposes complications on the police force’s escort effort. While the municipal government has agreed to temporarily shut down a few roads for exclusive police use, the shut-down time windows vary among roads and are generally narrow to avoid excessively disturbing the life of the citizens. The motorcade of escort must pass through any road entirely within its shut-down time window and not use any road that the municipal government has not agreed to shut down. Given information about all roads available to the police force for the escort, determine the shortest escort time. Input The input contains a single test case. The first line contains four integers n, m, s and t (2 ≤ n ≤ 100; 0 ≤ m ≤ 1000; 1 ≤ s, t ≤ n; s ≠ t). There are n junctions, some pairs of which are connected by m roads. The court and the prison are located at the s-th and the t-th junctions, respectively. The next m lines each contain five integers x, y,b, e and c (1 ≤ x, y ≤ n; 0 ≤ b < e ≤ 104; 1 ≤ c ≤ 104), indicating that the directed lanes running from the x-th junction to the y-th junction of a road that takes the motorcade of escort c units of time to pass through will be shut down between time b and e. The earliest time when the motorcade can leave the court is time 0. Output If the escort is possible, print the shortest escort time; otherwise, print “Impossible”. Sample Input 4 5 1 4 1 2 0 1 1 1 2 0 1 2 1 3 1 3 2 2 4 3 4 1 3 4 3 4 1 Sample Output 3 Hint The sample is depicted in Figure 1. Each junction is represented by a numbered spot. Each road is represented by an arrow labeled with , its shut-down time window and pass-through time. Figure 1: Depiction of the sample The second road listed in the sample is virtually unusable for it takes the motorcade of escort longer time to pass through than it can stay available. The remaining four roads enable the following two escort routes: (The label  over an arrow indicates that the motorcade passes through the corresponding road between time s and t.) The first route takes four units of escort time, whereas the second takes three, which is the shortest possible. Source PKU Campus 2008 (POJ Founder Monthly Contest – 2008.05.10), frkstyc

[Submit]   [Go Back]   [Status]   [Discuss]

【题意】有n个点，m条边，求从 s 点到 t 点的最短时间。每条边从x到y有规定的通行时间b~e时刻，消耗c时间通过。

【分析】求起点到终点的最短时间耗费，每条路限制只在一定的时间范围内可以通行。最优起始时间不确定，故需要枚举。

【代码如下】

/**
[最短路+枚举]poj 3594
求起点到终点的最短时间耗费，每条路限制只在一定的时间范围内可以通行。
最优起始时间不确定，故需要枚举。
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

#define INF 100000000
#define N 101
struct node
{
    int u, d, s, e;
    //u 是到达地点, d 是耗时, s 是开始时间, e 是截止时间
    node(int a=0, int b=0, int c=0, int f=0)
    {
        u = a; d = b; s = c; e = f;
    }
}p;
vector<node> g[N];
int vis[N], d[N], n, m, src, dst;
bool operator < (const node &pp, const node &pt)
{
    return pp.d > pt.d;
}

int dij(int t)
{
    memset(vis, 0, sizeof(vis));
    for(int i=0; i<=n; i++) d[i] = INF;
    p = node(src, t);//src是到达地点, t是时刻
    d[src] = t;
    priority_queue<node> que;
    que.push(p);
    int u, v, w;
    while(!que.empty())
    {
        p = que.top(); que.pop();
        u = p.u;//到达地点
        if(vis[u]) continue;
        vis[u] = 1;
        if(u == dst)//到达目的地，返回时间差
            return (d[u] - d[src]);

        for(int i=0; i<g[u].size(); i++)
        {
            v = g[u][i].u;//到达地点
            w = g[u][i].d;//耗时
            if(d[u] < g[u][i].s){ //到达u的时刻 < 可通行开始时间
                if(g[u][i].s+w < d[v]){
                    d[v] = g[u][i].s+w; //更新到达v点的时刻，入队
                    que.push(node(v, d[v]));
                }
            }
            else if(d[u]+w <= g[u][i].e && d[u]+w < d[v]) //到达u点的时刻已经可以通行，并可耗时w通过
            {
                d[v] = d[u]+w; //更新到达v点的时刻，入队
                que.push(node(v, d[v]));
            }
        }
    }
    return INF;
}

int main()
{
    int x, y, s, e, c, mint, maxt;
    while(scanf("%d %d %d %d", &n, &m, &src, &dst)!= EOF)
    {
        mint = INF;
        maxt = 0;
        memset(g, 0, sizeof(g));
        while(m--)
        {
            scanf("%d %d %d %d %d", &x, &y, &s, &e, &c);
            //x 是起点, y 是到达点, s 是开始时间, e 是截止时间, c 是耗时
            if(e-s+1 < c) continue;
            g[x].push_back(node(y, c, s, e));
            if(x == src)
            {
                mint = min(mint, s);
                maxt = max(maxt, s);
            }
        }
        int res = INF, tmp;
        for(x=mint; x<=maxt; x++)
        {
            tmp = dij(x);
            if(tmp == INF) break;
            res = min(res, tmp);
        }
        if(res==INF)    printf("Impossible\n");
        else    printf("%d\n", res);
    }
    return 0;
}