Acwing-基础算法课笔记之搜索与图论（spfa算法）

一、spfa算法

1、概述

单源最短路径算法，处理负权边的spfa算法，一般时间复杂度为$O(m)$，最坏为$O(nm)$。
1、建立一个队列，初始化队列里只有起始点（源点）；
2、在建立一个表格（dist）记录起始点到所有点的最短路径（该表格的初始值要赋为无穷大，该点到他本身的路径赋为0）；
3、然后执行松弛操作，用队列里有的点作为起始点去刷新到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。

2、模拟过程

如图所示：

1、初始化距离

	a	b	c	d	e	f	g
d[i]	0	$\infty$	$\infty$	$\infty$	$\infty$	$\infty$	$\infty$

2、首先源点a入队，当队列非空时：
（1）队首元素（a）出队，对以a为起始点的所有边的终点依次进行更新操作（此处有b、c、d三个点），此时路径表格状态为：

	a	b	c	d	e	f	g
d[i]	0	24	8	15	$\infty$	$\infty$	$\infty$

3、在松弛时三个点的最短路径估值变小了，而这些点队列中都没出现，这些点需要入队，此时，队列中新入队了三个节点b、c、d。队首元素b点出队，对以b为起始点的所有边的终点依次进行松弛操作（此处只有e点），此时路径表格状态为：

	a	b	c	d	e	f	g
d[i]	0	24	8	15	30	$\infty$	$\infty$

4、最短路径表中，e的最短路径估值也变小了，e在队列中不存在，因此e也要入队，此时队列中的元素为c、d、e。队首元素c点出队，对以c为起始点的所有边的终点依次进行松弛操作（此处有e、f两个点），此时路径表格状态为：

	a	b	c	d	e	f	g
d[i]	0	24	8	15	15	11	$\infty$

结果为：

	a	b	c	d	e	f	g
d[i]	0	24	8	15	15	11	14

3、spfa算法模板（队列优化的Bellman-Ford算法）

时间复杂度平均情况下$O(m)$，最坏情况下$O(nm)$，$n$表示点数，$m$表示边数

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中
// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    queue<int> q;
    q.push(1);
    st[1] = true;
    while (q.size())
    {
        auto t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

Acwing-spfa算法模板（队列优化的Bellman-Ford算法）

4、spfa算法模板（判断图中是否存在负环）

时间复杂度是$O(nm)$，$n$表示点数，$m$表示边数

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中
// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。
    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }
    while (q.size())
    {
        auto t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return false;
}

Acwing-spfa算法模板(判断图中是否存在负环)