题目链接

• 题意：
  给一个有向图，n点m边。每个边有一个时间段，只有在这个时间段才能通过，经过时需要时间。求s到t，路上花费的最短时间（在起点停留的时间不算）
  2 ≤ n ≤ 100; 0 ≤ m ≤ 1000; 1 ≤ s, t ≤ n; s ≠ t
  
• 分析：
  最开始想的还是拆点计算，但是显然无解。仔细想想，不用拆点也是可以的。对于之前遇到的某道题，对于当前点，从不同的方向过来对之后的答案是有影响的，这种情况就必须要拆点了。但是这个题目的限制是时间，对于当前点，到达时间越短肯定是越优的，所以不用拆点，贪心即可。
  需要处理的就是开始时间的问题，最开始没有暴力枚举，只是枚举了起点所连的边的起始时间，这样其实是不对的。

const int MAXV = 110;

struct Edge
{
    int from, to, l, r, dist;
};

struct HeapNode
{
    int d, u;
    bool operator < (const HeapNode& rhs) const
    {
        return d > rhs.d;
    }
};

struct Dijkstra
{
    int n, m;           //n:点数 m:边
    vector<Edge> edges; //存储所有的边
    vector<int> G[MAXV];//每个点的所有相邻边序号
    bool done[MAXV];    // 是否已永久标号
    int d[MAXV];        // s起点到各个点的距离
    int p[MAXV];        // 最短路树中的上一条边序号

    void init(int n)
    {
        this->n = n;
        for(int i = 0; i < n; i++) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int l, int r, int dist)
    {
        edges.push_back((Edge) { from, to, l, r, dist });
        m = edges.size();
        G[from].push_back(m - 1);
    }

    void dijkstra(int s, int v)
    {
        priority_queue<HeapNode> Q;
        for(int i = 0; i < n; i++) d[i] = INF;
        d[s] = v;
        memset(done, 0, sizeof(done));
        Q.push((HeapNode) { 0, s });
        while(!Q.empty())
        {
            HeapNode x = Q.top();
            Q.pop();
            int u = x.u;
            if(done[u]) continue;
            done[u] = true;
            for(int i = 0; i < G[u].size(); i++)
            {
                Edge& e = edges[G[u][i]];
                int st = max(d[u], e.l);
                if(d[e.to] > st + e.dist && st + e.dist <= e.r)
                {
                    d[e.to] = st + e.dist;
                    p[e.to] = G[u][i];
                    Q.push((HeapNode) { d[e.to], e.to });
                }
            }
        }
    }
} dij;

int main()
{
    int n, m, s, e;
    while (~RIV(n, m, s, e))
    {
        dij.init(n + 1);
        REP(i, m)
        {
            int u, v, l, r, c;
            RV(u, v, l, r, c);
            if (r - l < c)
                continue;
            dij.AddEdge(u, v, l, r, c);
        }
        int ans = INF;
        REP(i, 11000)
        {
            dij.dijkstra(s, i);
            if (dij.d[e] != INF)
                ans = min(ans, dij.d[e] - i);
        }
        if (ans != INF)
            WI(ans);
        else
            puts("Impossible");
    }
    return 0;
}