论没钱加油的车如何走到终点-最短路
定义外的一些补充：
-
对于边权为正的图，任意两个结点之间的最短路，不会经过重复的结点。
-
对于边权为正的图，任意两个结点之间的最短路，不会经过重复的边。
-
对于边权为正的图，任意两个结点之间的最短路，任意一条的结点数不会超过 \(n\)，边数不会超过 \(n-1\)。
以上三条补充，都提到了“对于边权为正的图”.
那么不妨考虑一下“对于边权出现负数的图”，如果边权为负，
就意味着，可以重复走一条边来实现”刷步数“的操作，如果是这样，
那么最短路最终为无穷小.因为没有刷边，所以每条边就走一次.
Floyd：
虽然复杂度达到了 \(O(n^3)\),但该算法可以求图中
任意两点的最短路.不过前提条件是不能出现负环.
实现：
原始形式:定义三维数组 $dp\left [ k\right ] \left [ x\right ] \left [ y \right ] $ ，表示只允许经过前 \(k\) 个节点，节点 \(x\) 到 \(y\) 的最短路径.
有了定义，如何求出 $dp\left [ k\right ] \left [ x\right ] \left [ y \right ] $ 的值呢？
首先，对于任意 \(dp\left[0\right]\left[x\right]\left[y\right]\) 的值，我们是可以立马求出来的，即0，\(x\) 与 \(y\) 的边权，或正无穷.
以下是分组讨论：
x与y的边权:当x与y之间有直接边相连.
0:当x与y为同一节点.
正无穷：因为k为0，所以此时无法到达.
再接，对于任意 $dp\left [ k\right ] \left [ x\right ] \left [ y \right ] $ ,方程为dp[k][x][y] = min(dp[k-1][x][y], dp[k-1][x][k] + dp[k-1][k][y]).
下面对min函数内做解释.
dp[k-1][x][y]:即只能走前k-1个节点，如果当前可以走k号节点没有做到更短，则沿用旧的路线.
dp[k-1][x][k] + dp[k-1][k][y]:即相当于走k号节点，将两段部分的距离加在一起.
然而，方程中的k - 1真的有意义吗？当更新dp[k][k][x]或dp[k][x][k]时，
将前者代入方程中可得到dp[k][k][x] = min(dp[k-1][k][x], dp[k-1][k][k]+dp[k-1][k][x]).
但是dp[k-1][k][k]的值为0，因此结果总是dp[k-1][k][x].根据这个例子，也能推断
后者的结论也相似.
因此，如果省略第一维，在给定的k下，每个元素的更新中使用到的元素都没有在这次迭代中更新，因此第一维的省略并不会影响结果。
丢掉第一维后，复杂度为多少呢？
-
时间复杂度：三重循环，依次枚举k，x，y.复杂度为 \(O(n^3)\).
-
空间复杂度：在节省了一个维度后，复杂度为 \(O(n^2)\).
模板代码：
for (k = 1; k <= n; k++) {//一定先枚举k！
for (x = 1; x <= n; x++) {
for (y = 1; y <= n; y++) {
f[x][y] = min(f[x][y], f[x][k] + f[k][y]);
}
}
}
模板题：
给出一张由 \(n\) 个点 \(m\) 条边组成的无向图。
求出所有点对 \((i,j)\) 之间的最短路径。
本题就是模板题，但要注意重边的情况.
代码：
#include<bits/stdc++.h>
using namespace std;
const int inf = 100000000;
int n,m,u,v,w,a[105][105],dp[105][105];
int main(){
cin >> n >> m;
while(m--){
cin >> u >> v >> w;
if(a[u][v]) a[u][v] = min(a[u][v],w);
else a[u][v] = w;
if(a[v][u]) a[v][u] = min(a[v][u],w);
else a[v][u] = w;
}
for(int i = 1;i <= n;i++){
for(int j = 1;j <= n;j++){
if(!a[i][j]) dp[i][j] = inf;
else dp[i][j] = a[i][j];
}
dp[i][i] = 0;
}
for(int k = 1;k <= n;k++){
for(int i = 1;i <= n;i++){
for(int j = 1;j <= n;j++){
dp[i][j] = min(dp[i][j],dp[i][k] + dp[k][j]);
}
}
}
for(int i = 1;i <= n;i++){
for(int j = 1;j <= n;j++) cout<<dp[i][j]<<" ";
cout<<'\n';
}
}
Dijkstra:
Dijkstra虽然是用来解决单个节点到其他节点的最短路径，
但是它的方法绝不会像隔壁的Floyd那般粗鲁.
Dijkstra朴素算法复杂度为 \(O(n^2)\)，但在优先队列优化后为 \(O((n\;+\;m)\,log\,n)\).
以下为算法流程:
1.将选定的节点加入集合.
补：每个节点都拥有一个dis值，选定节点dis值为0，其他为正无穷.
2.挑选集合中dis值最小的节点，对其直接连接的所有边进行松弛操作.
松弛步骤如下：
1.假设集合中节点为 \(u\)，其连接节点为 \(v\) ,之间边权为 \(w\).
若满足 \(dis\left [v\right ]\;>\;dis\left [u\right ]\;+\;w\),则更新 \(dis\left [v\right ]\) 的值，并将v加入至集合中.2.一直持续下去，直到所有被连接的节点都完成了操作.
3.进行完松弛操作后，将该节点从集合中删除，然后重复步骤2，直到集合中无节点.
该算法朴素做法是在每次松弛操作结束后，暴力寻找集合中dis值最小的元素.
将所有步骤2都执行完后复杂度为 \(O(m)\) (即边的数量),步骤1为 \(O(n^2)\),
加起来最终复杂度为 \(O(n^2\;+\;m)\;=\;O(n^2)\)
关于“查找最小”这个操作，我们可以对其进行优化.由于本人实力有限QAQ，所以
采用优先队列优化.通过维护一个小根堆，来做到队首元素始终为最小.优化过后，
复杂度为 \(O(m\,log\,n)\) .
模板例题：
给定一个n个点，m条有向边的带非负权图，请你计算从s出发，到每个点的距离。
代码：
#include<bits/stdc++.h>
using namespace std;
bool vis[100005];
int n,m,s,dis[100005];
struct edge{
int to,w;
};
struct node{
int v,dis;
node(int a,int b){v = a,dis = b;}
bool operator <(const node &u)const {return dis > u.dis;}
};
priority_queue<node> q;
vector<edge> G[100005];
int main(){
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
cin >> n >> m >> s;
for(int i = 1;i <= n;i++) dis[i] = 1e9 + 7;
dis[s] = 0;
while(m--){
int u , v , w;
cin >>u >> v >> w;
edge t = {v,w};
G[u].push_back(t);
}
q.push({s,0});
while(!q.empty()){
node tmp = q.top();q.pop();
if(vis[tmp.v]) continue;
vis[tmp.v] = 1;
dis[tmp.v] = tmp.dis;
for(int i = 0;i < G[tmp.v].size();i++){
if(vis[G[tmp.v][i].to]) continue;
if(dis[G[tmp.v][i].to] > dis[tmp.v] + G[tmp.v][i].w)
q.push({G[tmp.v][i].to,dis[tmp.v] + G[tmp.v][i].w});
}
}
for(int i = 1;i <= n;i++) cout<<dis[i]<<" ";
return 0;
}
当然，如果遇到了边权出现负数的情况，Dijkstra也只能无能狂怒.
浙公网安备 33010602011771号