POJ 3594 Escort of Dr. Who How(最短路+枚举)

题意：有n个城市道路，每个道路只能再一段区间[b,e]内可行，有给出每条道路的经过时间，问从出发开始时间st到结束最快结束时间en，的差en-st最小是多少。

思路：由于出发时间是不定的，当然可以用dfs暴搜，不过复杂度是肯定不能承受的，所以我们可以枚举开始时间start，这样就能对每个路段进行限制，在处理路段时，假如到达一个路段的时间为t0,只有满足下列条件，这条路段才是可行的（不包括c>e-b，因为这种情况开始就可以排除) 条件：t0+c <= e,然后经过完这条线路时，此路段结束时间为 max{t0+c,b+c}。

算法：对出发时间st从小到大枚举，每次bfs,dij求最短路时更新时间差，直到对于一个st*，不存在可行路径，返回最小值，这个值就是答案，我们可以证明对于一个出发时间st，他的解包括了st*的解（st*>st)，因为考虑一个st时，我们完全可以延后到st*在出发！所以最后得到的值是最优的。

PS：话说最近做的枚举题已经超过了图论了.......

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <memory.h>
#include <cmath>
#include <bitset>
#include <queue>
#include <vector>
using namespace std;

const int BORDER = (1<<20)-1;
const int MAXSIZE = 37;
const int MAXN = 1105;
const int INF = 1000000000;
#define CLR(x,y) memset(x,y,sizeof(x))
#define ADD(x) x=((x+1)&BORDER)
#define IN(x) scanf("%d",&x)
#define OUT(x) printf("%d\n",x)
#define MIN(m,v) (m)<(v)?(m):(v)
#define MAX(m,v) (m)>(v)?(m):(v)
#define ABS(x) ((x)>0?(x):-(x))

#define SET_NODE(no,a,b) {no.u=a;no.val=b;}

typedef struct{
    int u;
    int val;
}Node;
typedef struct{
    int v,next;
    int b,e;
    int c;
}Edge;

Edge edge[MAXN*MAXN];
Node t_node,node;
int n,m,s,t,index,mmin,mmax;
int net[MAXN],tim[MAXN];
bool visit[MAXN];

bool operator < (const Node& a,const Node& b)
{
    return a.val > b.val;
}
void add_edge(const int& u,const int& v,const int& b,
        const int& e,const int& c)
{
    edge[index].v = v;
    edge[index].b = b;
    edge[index].e = e;
    edge[index].c = c;
    edge[index].next = net[u];
    net[u] = index++;
}
int init()
{
    index = 0;
    CLR(visit,0);
    CLR(net,-1);
    CLR(tim,127);
    return 0;
}
int input()
{
    int i,j,u,v,b,e,c;
    for(i = 0; i < m; ++i)
    {
        scanf("%d%d%d%d%d",&u,&v,&b,&e,&c);
        if(c > e - b)
            continue;
        add_edge(u,v,b,e,c);
    }
    return 0;
}
int bfs(const int& tim_st)
{
    int u,v,tmp,cur,i;
    priority_queue<Node> que;
    while(!que.empty())
        que.pop();
    SET_NODE(t_node,s,tim_st);
    que.push(t_node);
    while( !que.empty())
    {
        node = que.top();
        que.pop();
        u = node.u;
        cur = node.val;
        if(u == t)
            return cur - tim_st;
        for(i = net[u]; i != -1; i = edge[i].next)
        {
            v = edge[i].v;
            tmp = MAX(cur,edge[i].b);
            tmp += edge[i].c;
            if(tmp > edge[i].e)
                continue;
            if(tmp > tim[v])
                continue;
            tim[v] = tmp;
            SET_NODE(t_node,v,tmp);
            que.push(t_node);
        }
    }
    return -1;
}
int work()
{
    int i,j,ans,tmp;
    ans = INF;
    mmin = INF;
    mmax = -1;
    for( i = net[s]; i != -1; i = edge[i].next)
    {
        mmin = MIN(mmin,edge[i].b);
        mmax = MAX(mmax,edge[i].e);
    }
    for( i = mmin; i <= mmax; ++i)
    {
        CLR(tim,127);
        tmp = bfs(i);
        if(tmp == -1)
            break;
        ans = MIN(ans,tmp);
    }
    if(ans == INF)
        printf("Impossible\n");
    else
        OUT(ans);
    return 0;
}
int main()
{
    while(scanf("%d%d%d%d",&n,&m,&s,&t)!=EOF)
    {
        init();
        input();
        work();
    }
    return 0;
}