Bellman-Ford算法和SPFA算法

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算法代码源码