作者：血小板自动机
链接：https://blog.dalao.icu/archives/8.html
题目传送门
解题思路
这题因为数据量比较小，可以使用多种最短路算法来解决，是一道经典的模板题，下面附上 floyd 算法、dijkstra 算法、Bellman-Ford 、spfa 算法、以及 dijkstra + heap 优化的代码。
坑点：这题可能一个城市到另一个城市有多条路径，我们记录的时候，要记录最小的那条路径，不能记录最后的那条路径，解其他题目的时候也要注意。以及，注意城市的起始点是从0开始算还是1开始算。
Floyd算法
该算法极其暴力，时间复杂度为 ,但是算法简单，核心代码只有4~5行，非常容易理解。
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 205;
int ma[N][N];
int n, m, st, ed;
void init()
{
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
ma[i][j] = (i == j ? 0 : INF);
}
void Floyd()
{
for(int k = 0; k < n; k++)
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
ma[i][j] = min(ma[i][j], ma[i][k] + ma[k][j]);
}
int main(void)
{
int a, b, c;
while(cin >> n >> m) {
init();
for(int i = 0; i < m; i++) {
cin >> a >> b >> c;
if(ma[a][b] > c)
ma[a][b] = ma[b][a] = c;
}
Floyd();
cin >> st >> ed;
cout << (dis[ed] == INF ? -1 : dis[ed]) << endl;
}
return 0;
}
Dijsktra算法
这个算法是用来针对无负边权的单源最短路径问题的，它比 floyd 算法高效。 对这里这个第一个循环 i<=n-1 的解释： n 个点，1到任何一个点的最短路径边数不会超过 n-1，因为就算 n 个点全部连起来，也只有 n-1 条边。
因为最短路径是一个不包含回路的简单路径，回路分为正权回路(回路权值之和为正)和负权回路(回路权值之和为负)。如果最短路径中包含正权回路，那么去掉这个回路，一定可以得到更短的路径；如果最短路径中包含负权回路，那么肯定没有最短路径，因为每多走一次负权回路就可以得到更短的路径. 因此最短路径肯定是一个不包含回路的最短路径，即最多包含 n-1 条边。
容易证明，Dijkstra 算法每一次循环可以确定一个顶点的最短路径，所以至多循环 n-1 次即可完成最短路求解。
算法时间复杂度：
注：dijsktra算法无法解决负边权问题。
#include <iostream>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f, N = 205;
int ma[N][N];
int dis[N];
bool vis[N];
int n, m, st, ed;
void init()
{
//初始化ma数组
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
ma[i][j] = (i == j ? 0 : INF);
}
void Dijk()
{
for (int i = 0; i < n - 1; i++){
int minv = INF, k;//k用来存储最小的且没被松弛过的城市
for (int j = 0; j < n; j++){
if (minv > dis[j] && !vis[j]){
minv = dis[j];
k = j;
}
}
vis[k] = 1;
for (int h = 0; h < n; h++)
dis[h] = min(dis[h], dis[k] + ma[k][h]);
}
}
int main(void)
{
int a, b, c;
while (cin >> n >> m){
//初始化ma数组
init();
for (int i = 0; i < m; i++){
cin >> a >> b >> c;
if (ma[a][b] > c)
ma[a][b] = ma[b][a] = c;
}
//输入起点和终点
cin >> st >> ed;
//初始化dis数组
for (int i = 0; i < n; i++)
dis[i] = ma[st][i];
//初始化vis数组
memset(vis, 0, sizeof vis);
vis[st] = 1;
Dijk();
cout << (dis[ed] == INF ? -1 : dis[ed]) << endl;
}
return 0;
}
Dijsktra + heap 优化
使用优先队列，每次找寻最小距离的点，这里有一个技巧，因为 greater 对 pair 的比较，是先比较第一个的，所以把 dis[i] 放在第一位。
这里如果使用邻接表+优先队列来存储，可以将时间复杂度优化至 ，该算法时间复杂度小于
当存在大量边的情况下，可以考虑使用邻接表存图。
//邻接矩阵写法
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 205;
typedef pair<int, int> P;
int arr[N][N];
int dis[N];
bool vis[N];
int n, m, st, ed;
void init()
{
memset(dis, INF, sizeof dis);
memset(vis, false, sizeof vis);
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
arr[i][j] = (i == j ? 0 : INF);
}
void Dijk()
{
dis[st] = 0;
priority_queue<P, vector<P>, greater<P> > que;
que.push(P(0, st));
while(que.size()) {
P p = que.top(); que.pop();
int vi = p.second;//点的索引
if(vis[vi])
continue;
vis[vi] = true;
for (int i = 0; i < n; i++) {
if (!vis[i] && dis[i] > dis[vi] + arr[vi][i]) {
dis[i] = dis[vi] + arr[vi][i];
que.push(P(dis[i], i));
}
}
}
}
int main()
{
int a, b, c;
while(cin >> n >> m) {
init();
for(int i = 0; i < m; i++) {
cin >> a >> b >> c;
if (arr[a][b] > c)
arr[a][b] = arr[b][a] = c;
}
cin >> st >> ed;
Dijk();
cout << (dis[ed] == INF ? -1 : dis[ed]) << endl;
}
return 0;
}
//邻接表写法
#include <bits/stdc++.h>
#define PUSH(x,y,z) G[x].push_back(P(y,z)) // 宏函数
using namespace std;
const int INF = 0x3f3f3f3f, N = 205;
typedef pair<int, int> P;
int n, m, st, ed;
vector<P> G[N];
int dis[N];
bool vis[N];
void init()
{
for(int i = 0; i < N; i++)
G[i].clear();
memset(dis, INF, sizeof dis);
memset(vis, false, sizeof vis);
}
void Dijk()
{
dis[st] = 0;
priority_queue<P, vector<P>, greater<P> > que;
que.push(P(0, st));
while(que.size()) {
P p = que.top(); que.pop();
int u = p.second;
if(vis[u])
continue;
vis[u] = true;
for(int i = 0; i < G[u].size(); ++i) {
int v = G[u][i].first;
int cost = G[u][i].second;
if(!vis[v] && dis[v] > dis[u] + cost) {
dis[v] = dis[u] + cost;
que.push(P(dis[v], v));
}
}
}
}
int main(void)
{
int a, b, c;
while(cin >> n >> m) {
init();
for(int i = 0; i < m; ++i) {
cin >> a >> b >> c;
PUSH(a, b, c);
PUSH(b, a, c);
}
cin >> st >> ed;
Dijk();
cout << (dis[ed] == INF ? -1 : dis[ed]) << endl;
}
return 0;
}
Bellman-flod算法
Djikstra 算法无法解决负权边问题，但是这个算法可以解决，并且它的核心语句只有四行，堪称完美。 这里同理，循环 n-1 次，因为 n 个点最多的边数是 n-1 条。 因为这个算法可以检测是否存在负权边，如果存在负权边，则无最短路径，若未出现负权边，则得出结果
我们增加一个 pro 数组来记录上一次的数据，如果更新后数据未变，则说明所有点的最短路径已经求得，提前结束，可提高效率。
负权检测，若再进行一次松弛，数组改变了，则说明这个图一定含负边权。
注：一般使用该算法来解决存在负边权的题目。
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1005;
int n, m, st, ed;
int pro[N], dis[N], u[N], v[N], w[N]; //u数组为起点，v数组为终点，w数组为边权，每一个组合表示一条边
bool vis[N]; //判断是否访问过该点
void Bellman_Ford()
{
for(int k = 0; k < n - 1; ++k) {
for(int i = 0; i < n; ++i) pro[i] = dis[i];
for(int i = 0; i < m; ++i) {
dis[v[i]] = min(dis[v[i]], dis[u[i]] + w[i]);
dis[u[i]] = min(dis[u[i]], dis[v[i]] + w[i]); //无向图需要反向做一次松弛
}
bool check = false;
//松弛完毕检测dis数组是否有更新，如果没有更新，则可以判断更新完毕，提高效率
for(int i = 0; i < n; ++i)
if(pro[i] != dis[i]) {
check = true;
break;
}
if(check) continue;
}
bool flag = false;
for(int i = 0; i < m; ++i)
if(dis[v[i]] > dis[u[i]] + w[i]) {
flag = true;
break;
}
if(flag) cout << "该图含有负权回路" << endl;
}
int main()
{
while(cin >> n >> m) {
for(int i = 0; i < m; ++i) cin >> u[i] >> v[i] >> w[i];
memset(dis, INF, sizeof dis);
cin >> st >> ed;
dis[st] = 0;
Bellman_Ford();
cout << (dis[ed] == INF ? -1 : dis[ed]) << endl;
}
return 0;
}
Bellman-flod算法+队列优化（spfa算法）
这个算法利用 BFS 思路，还能检测负权边，堪称万能算法，时间复杂度还能接受。 下面给出两种写法：邻接表的写法和邻接矩阵的写法。这个算法跟 BFS 算法不一样的地方就是，BFS 一旦出队的点就不在入队了，而 spfa 算法，出队的点还有可能入队，因为可能起点到该点的估计值再次变小。
//邻接矩阵写法
#include <bits/stdc++.h>
#define PUSH(x,y,z) G[x].push_back({y,z}) // 宏函数
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1005;
typedef pair<int, int> P;
int n, m, st, ed;
int dis[N], arr[N][N];
bool vis[N];
void init()
{
for(int i = 0; i < n; ++i)
for(int j = 0; j < n; ++j)
arr[i][j] = i == j ? 0 : INF;
memset(dis, INF, sizeof dis);
memset(vis, false, sizeof vis);
}
void spfa()
{
queue<int> q;
vis[st] = true, dis[st] = 0;
q.push(st);
while(q.size()) {
int now = q.front();
q.pop(); vis[now] = false;
for(int i = 0; i < n; ++i) {
if(dis[i] > dis[now] + arr[now][i]) {
dis[i] = dis[now] + arr[now][i];
if(!vis[i]) {
vis[i] = true;
q.push(i);
}
}
}
}
}
int main()
{
int a, b, c;
while(cin >> n >> m) {
init();
for(int i = 0; i < m; ++i) {
cin >> a >> b >> c;
arr[a][b] = arr[b][a] = min(arr[a][b], c);
}
cin >> st >> ed;
spfa();
cout << (dis[ed] == INF ? -1 : dis[ed]) << endl;
}
return 0;
}
//邻接表写法
#include <bits/stdc++.h>
#define PUSH(x,y,z) vec[x].push_back({y,z}) // 宏函数
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1005;
typedef pair<int, int> P;
int n, m, st, ed;
vector<P> vec[N];
int dis[N]; // 起点到终点的距离
bool vis[N]; // 判断是否在队列里面
void init()
{
for(int i = 0; i < N; ++i) vec[i].clear();
memset(dis, INF, sizeof dis);
memset(vis, false, sizeof vis);
}
void Spfa()
{
queue<int> q;
q.push(st); dis[st] = 0, vis[st] = true;
while(q.size()) {
int now = q.front();
q.pop(); vis[now] = false;
for(int i = 0; i < vec[now].size(); ++i) {
int v = vec[now][i].first;
if(dis[v] > dis[now] + vec[now][i].second) {
dis[v] = dis[now] + vec[now][i].second;
if(!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
}
int main()
{
int a, b, c;
while(cin >> n >> m) {
init();
for(int i = 0; i < m; ++i) {
cin >> a >> b >> c;
PUSH(a, b, c);
PUSH(b, a, c);
}
cin >> st >> ed;
Spfa();
cout << (dis[ed] == INF ? -1 : dis[ed]) << endl;
}
return 0;
}