Bellman-Ford算法
能够处理存在负边权的情况。
算法时间复杂度:O(n*m)，n是顶点数，m是边数。
算法实现:
设s为起点，dis[v]即为s到v的最短距离，pre[v]为v前驱。w[j]是边j的长度，且j连接u、v。
dis[s] = 0;
dis[v] = 0x3f3f3f3f;
pre[s] = 0;
for (i = 1; i <= n - 1; i++)//松弛n-1次
{
for (j = 1; j <= m; j++)//注意要枚举所有边，不能枚举点
{
if (dis[u[j]] + w[j] < dis[v[j]])//u[j],v[j]分别是这条边连接的两个起点与终点
{
dis[v[j]] = dis[u[j]] + w[j];
pre[v[j]] = u[j];
}
}
}
核心思想:看看能否通过w[j]这条边，使得1号顶点到v[j]号顶点的距离变短
需要松弛多少遍呢?
至多n-1遍，因为一条最短路径的长度最多为n-1条边。所以，在实际操作中，该算法经常会在未达到n-1轮松弛前就已经计算出最短路径。
鉴于此，就有优化的方法，且看SPFA算法。
我们来做一道题
依旧是最短路这道题https://acm.hdu.edu.cn/showproblem.php?pid=2544
代码如下：
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N = 1e4 + 10;
const int M = 2e4 + 10; // M 需要更大一些，因为每条边存两次
long long dis[N], u[M], v[M], w[M];
int n, m, cnt;
long long ans;
long long Bellman_Ford(int s, int t)
{
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
for (int i = 1; i <= n - 1; i++)
{
int check = 0;
// 枚举每一条边
for (int j = 0; j < cnt; j++)
{
if (dis[u[j]] + w[j] < dis[v[j]])
{
dis[v[j]] = dis[u[j]] + w[j];
check = 1;
}
}
if (check == 0)
{
break;
}
}
return dis[t];
}
int main()
{
while (scanf("%d %d", &n, &m) != EOF && (n + m))
{
cnt = 0; // 从 0 开始
for (int i = 1; i <= m; i++)
{
int x, y, z;
cin >> x >> y >> z;
// 无向图
u[cnt] = x, v[cnt] = y, w[cnt] = z;
cnt++;
u[cnt] = y, v[cnt] = x, w[cnt] = z;
cnt++;
}
ans = Bellman_Ford(1, n);
if (ans >= 0x3f3f3f3f3f3f3f3fLL)
cout << "No path" << endl;
else
cout << ans << endl;
}
return 0;
}
负权回路
负权回路是指边权之和为负数的一条回路，上图中1->2->4这条回路的边权之和为-8.在有负权回路的情况下，从1到3的最短路径是多少?答案是无穷小，因为我们可以绕这条负权回路走无数圈，每走一圈路径值就减去8，最终达到无穷小。
所以说存在负权回路的图无法求出最短路径，Bellman-Ford算法可以在有负权回路的情况下输出错误提示，
如果在Bellman-Ford算法的两重循环完成后，还是存在某条边使得：dis[u]+w<dis[v]，则存在负权回路：
for每条边(u， v)
if (dis[u]+w<dis[v]) return False
如果我们规定每条边只能走一次，在这个前提下可以求出负权回路的最短路径。
Bellman-Ford算法源码代码
SPFA算法
队列优化的Bellman-Ford算法
SPFA是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
主要思想是：
初始时将起点加入队列。每次从队列中取出一个元素，并对所有与它相邻的点进行修改，若某个相邻的点修改成功，则将其入队。直到队列为空时算法结束。
这个算法，简单的说就是队列优化的bellman-ford，利用了每个点不会更新次数太多的特点发明的此算法，
SPFA在形式上和广度优先搜索非常类似，不同的是广度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是说一个点修改过其它的点之后，过了一段时间可能会获得更短的路径，于是再次用来修改其它的点，这样反复进行下去。
算法时间复杂度：O(kE)，E是边数。K是常数，平均值为2。
我们来看一道题
洛谷3371
代码如下：
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<queue>
#incldue<string>
using namespace std;
const int N = 1e4; // 定义最大节点数
const int M = 1e4; // 定义最大边数
// 边的结构体
struct E {
int to; // 边的终点
int w; // 边的权重
int next; // 下一条边的索引
} e[M];
// 头指针数组，存储每个节点的第一条边
int head[M];
int tot; // 边的总数
int n, m; // 节点数和边数
int vis[N]; // 记录节点是否在队列中
int dis[N]; // 存储每个节点到起点的最短距离
// 初始化函数
void init()
{
tot = 0; // 边的数量初始化为0
memset(head, -1, sizeof(head)); // 初始化头指针数组为-1，表示没有边
}
// 添加边的函数
void addEdge(int u, int v, int w)
{
e[tot].to = v; // 设置边的终点
e[tot].w = w; // 设置边的权重
e[tot].next = head[u]; // 设置当前边的下一条边
head[u] = tot; // 将当前边加入到头指针中
tot++; // 边的总数加1
}
// 输出图的函数
void output()
{
// 遍历所有节点
for (int i = 1; i <= n; i++)
{
// 遍历当前节点的所有边
for (int j = head[i]; j != -1; j = e[j].next)
{
int v = e[j].to; // 终点
int w = e[j].w; // 权重
cout << i << " " << v << " " << w << endl; // 输出边的信息
}
}
}
// SPFA算法
void SPFA(int t)
{
queue<int> q; // 定义一个队列
memset(dis, 0x3f, sizeof(dis)); // 初始化距离数组为很大的值
dis[t] = 0; // 起点到自己的距离为0
q.push(t); // 将起点加入队列
vis[t] = 1; // 标记起点为已访问
while (!q.empty()) // 当队列不为空时
{
int cur = q.front(); // 取出队首元素
q.pop(); // 弹出队首元素
vis[cur] = 0; // 标记为未访问
// 遍历当前节点的所有边
for (int i = head[cur]; i != -1; i = e[i].next)
{
int v = e[i].to; // 终点
int w = e[i].w; // 权重
// 如果找到更短的路径
if (dis[v] > dis[cur] + w)
{
dis[v] = dis[cur] + w; // 更新最短距离
// 如果该节点未被访问，则加入队列
if (!vis[v])
{
q.push(v);
vis[v] = 1; // 标记为已访问
}
}
}
}
}
int main()
{
int n, m, t; // n为节点数，m为边数，t为起点
cin >> n >> m >> t; // 输入节点数、边数和起点
init(); // 初始化图
// 输入边的信息
for (int i = 1; i <= m; i++)
{
int u, v, w; // 边的起点、终点和权重
cin >> u >> v >> w; // 输入边的信息
addEdge(u, v, w); // 添加边
}
SPFA(t); // 执行SPFA算法
// 输出每个节点到起点t的最短距离
for (int i = 1; i <= n; i++)
{
cout << dis[i] << " "; // 输出距离
}
return 0; // 程序结束
}
如何输出最短路径
我们使用一个pre[x]数组来解决
void print(int x)
{
if(pre[a][x]==0) return;
print(pre[a][x]);
cout<<"->"<<x;
}
SPFA算法代码源码
