最短路问题是图论中最基础的问题。最短路是给定两个顶点,
在以这两个点为起点和终点的路径中,边的权值和最小的路径。
智力游戏中的求解最少步数问题也可以说是一种最短路问题。
如果图中不存在从s可达的负圈,那么最短路不会经过同一个点两次(也就是说,最多通过|V| - 1条边),
while(true)的循环最多执行|V| - 1次,因此,复杂度是O(|V|*|E|)。反之,如果存在
从s可达的负圈,那么在第|V|次循环中也会更新d的值,因此也可以用这个性质来检查负圈。
如果一开始对所有的顶点i,都把的d[i]初始化为0,那么可以检查出所有的负圈。
2.单源最短路问题2(Dijkstra算法)
(1)找到最短距离已经确定的顶点,从他出发更新相邻顶点的最短距离
(2)此后不需要再关心1中的“最短距离已经确定的顶点”。
在(1)(2)中提到的“最短距离已经确定的顶点”要怎么得到是问题的关键。在最开始,
只有起点的最短距离是确定的。而在尚未使用过的顶点中,距离的d[i]最小的顶点就是最短距离
已经确定的顶点。这是因为由于不存在负边,所有d[i]不会在之后的更新中变小。这个算法
叫做Dijkstra算法。
使用邻接矩阵实现的Dijkstra算法的复杂度是O(|V|2)。使用邻接表的话,更新最短距离只需要访问每条边一次
即可,因此这部分算法的复杂度是O(|E|)。但是每次要枚举所有的顶点来查找下一个使用的顶点,一次最终
复杂度还是O(|V|2)。因此使用数据结构进行优化。
下面是使用STL的priority_queue的实现。
3.任意两点间的最短路问题(Floyd-Warshall算法)
使用DP来求解任意两点间最短路问题。只使用顶点0~k和i,j的情况下,记i到j的最短路长度为
d[k+1][i][j]。k = -1时,认为只使用i和j,所以d[0][i][j] = cost[i][j]。接下来让我们把
只使用顶点0~k的问题归约到只使用0~k-1的问题上。
只使用0~k时,我们分i到j的最短路正好经过顶点k一次和完全不经过顶点k两种情况来讨论。
不经过顶点k的情况下,d[k][i][j] = d[k - 1][i][j].通过顶点k的情况下,d[k][i][j] =
d[k - 1][i][k] + d[k - 1][k][j].
合起来,就得到了d[k][i][j] = min(d[k - 1][i][j], d[k - 1][i][k] + d[k - 1][k][j])。
这个DP也可以使用同一个数组,不断进行d[i][j] = min(d[i][j], d[i][k] + d[k][j])的更新来实现。
4.路径还原
在求解最短距离时,满足d[j] = d[k] + cost[k][j]的顶点k,就是最短路上顶点j的前驱结点,
因此通过不断寻找前驱结点就可以恢复出最短路。时间复杂度是O(|E|).
在以这两个点为起点和终点的路径中,边的权值和最小的路径。
智力游戏中的求解最少步数问题也可以说是一种最短路问题。
1.单源最短路问题1(Bellman-Ford算法)
//从顶点from指向顶点to的权值为cost的边
struct edge { int from, to, cost; };
edge es[max]; //边
int d[maxn]; //最短距离
int V, E; //V是顶点数,E是边数
//求解从顶点s出发到所有点的最短距离
void short_path(int s)
{
for (int i = 0; i < V; i++){
d[i] = INF;
}
d[s] = 0;
while (true){
bool update = false;
for (int i = 0; i < E; i++){
edge e = es[i];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost){
d[e.to] = d[e.from] + e,cost;
update = true;
}
}
if (!update)
break;
}
}
如果图中不存在从s可达的负圈,那么最短路不会经过同一个点两次(也就是说,最多通过|V| - 1条边),
while(true)的循环最多执行|V| - 1次,因此,复杂度是O(|V|*|E|)。反之,如果存在
从s可达的负圈,那么在第|V|次循环中也会更新d的值,因此也可以用这个性质来检查负圈。
如果一开始对所有的顶点i,都把的d[i]初始化为0,那么可以检查出所有的负圈。
//如果返回true则存在负圈
bool find_negative_loop()
{
memset(d, 0, sizeof(d));
for (int i = 0; i < V; i++){
for (int j = 0; j < E; j++){
edge e = es[j];
if (d[e.to] > d[e.from] + e.cost){
d[e.to] = d[e.from] + e.cost;
//如果第n次仍然更新了,则存在负圈
if (i == V - 1)
return true;
}
}
}
return false;
}
2.单源最短路问题2(Dijkstra算法)
(1)找到最短距离已经确定的顶点,从他出发更新相邻顶点的最短距离
(2)此后不需要再关心1中的“最短距离已经确定的顶点”。
在(1)(2)中提到的“最短距离已经确定的顶点”要怎么得到是问题的关键。在最开始,
只有起点的最短距离是确定的。而在尚未使用过的顶点中,距离的d[i]最小的顶点就是最短距离
已经确定的顶点。这是因为由于不存在负边,所有d[i]不会在之后的更新中变小。这个算法
叫做Dijkstra算法。
int cost[maxn][maxn]; //cost[u][v]表示边e=(u,v)的权值(不存在这条边时设为INF)
int d[maxn]; //顶点s出发的最短距离
bool used[maxn]; //已经使用过的图
int V; //顶点数
//求从起点s出发到各个顶点的最短距离
void dijkstra(int s)
{
fill(d, d + V, INF);
fill(used, used + V; false);
d[s] = 0;
while (true){
int v = -1;
//从尚未使用过的顶点中选择一个距离最小的顶点
for (int u = 0; u < V; u++){
if (!used[u] && (v == -1 || d[u] < d[v]))
v = u;
}
if (v == -1)
break;
used[v] = true;
for (int u = 0; u < V; u++){
d[u] = min(d[u], d[v] + cost[v][u]);
}
}
}
使用邻接矩阵实现的Dijkstra算法的复杂度是O(|V|2)。使用邻接表的话,更新最短距离只需要访问每条边一次
即可,因此这部分算法的复杂度是O(|E|)。但是每次要枚举所有的顶点来查找下一个使用的顶点,一次最终
复杂度还是O(|V|2)。因此使用数据结构进行优化。
下面是使用STL的priority_queue的实现。
struct edge {int to, cost};
typedef pair<int, int> P; //first是最短距离,second是顶点的编号
int V;
vector<edge> G[maxn];
int d[maxn];
void dijkstra(int s)
{
//通过指定greater<P>参数,堆按照first从小到大的顺序取出值
priority_queue<P, vector<P>, greater<P> > que;
fill(d, d + V; INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()){
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++){
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost){
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
3.任意两点间的最短路问题(Floyd-Warshall算法)
使用DP来求解任意两点间最短路问题。只使用顶点0~k和i,j的情况下,记i到j的最短路长度为
d[k+1][i][j]。k = -1时,认为只使用i和j,所以d[0][i][j] = cost[i][j]。接下来让我们把
只使用顶点0~k的问题归约到只使用0~k-1的问题上。
只使用0~k时,我们分i到j的最短路正好经过顶点k一次和完全不经过顶点k两种情况来讨论。
不经过顶点k的情况下,d[k][i][j] = d[k - 1][i][j].通过顶点k的情况下,d[k][i][j] =
d[k - 1][i][k] + d[k - 1][k][j].
合起来,就得到了d[k][i][j] = min(d[k - 1][i][j], d[k - 1][i][k] + d[k - 1][k][j])。
这个DP也可以使用同一个数组,不断进行d[i][j] = min(d[i][j], d[i][k] + d[k][j])的更新来实现。
int d[maxn][maxn]; //d[u][v]表示边e = (u,v)的权值(不存在时设为INF,不过d[i][i] = 0)
int V; //顶点数
void warshall_floyd()
{
for (int k = 0; k < V; k++){
for (int i = 0; i < V; i++){
for (int j = 0; j < V; j++){
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
4.路径还原
在求解最短距离时,满足d[j] = d[k] + cost[k][j]的顶点k,就是最短路上顶点j的前驱结点,
因此通过不断寻找前驱结点就可以恢复出最短路。时间复杂度是O(|E|).
int prev[maxn]; //最短路上的前驱结点
//求从起点s出发到各个顶点的最短距离
void dijkstra(int s)
{
fill(d, d + V; INF);
fill(used, used + V, false);
fill(prev, prev + V, -1);
d[s] = 0;
while (true){
int v = -1;
for (int u = 0; u < V; u++){
if (!used[u] && (v == -1 || d[u] < d[v]))
v = u;
}
if (v == -1)
break;
used[v] = true;
for (int u = 0; u < V; u++){
if (d[u] > d[v] + cost[v][u]){
d[u] = d[v] + cost[v][u];
prev[u] = v;
}
}
}
}
//到顶点t的最短路
vector<int> get_path(int t)
{
vector<int> path;
for ( ; t != -1; t = prev[t])
path.push_back(t); //不断沿着prev[t]走直到t = s;
reverse(path.begin(), path.end());
return path;
}