题目链接
- 题意:
给一个有向图,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;
}