Bellman-Ford（单源最短路径）——队列优化

1.Bellman-Ford回顾

在上一篇的Bellman-Ford中讲到在其算法中需要经过双重循坏来解决边的“松弛”问题，但是通过对算法的详解可以了解，在每一次的循环中其实只有某几个节点需要“松弛”。所以，这次优化针对只需要“松弛”的节点。用一个队列来记录需要“松弛”的节点，也就是最短路径发生变化的点。

2.数据结构描述

在此次案例中，图的存储使用邻接表来表示，具体如下：

3.算法思想

每次选取队首顶点u，对顶点u的所有出边进行松弛操作。例如有一条u—>v的边，如果通过u—>v这条边使得源点带节点v的最短路径变短，而且顶点v不在当前的队列中，就将顶点v放入队尾。
值得注意的是，同一个顶点同时在队列中出现多次是毫无意义的，所以我们需要一个数组判断那些点已经在队列中。在对顶点u的所有出边松弛完毕后，就将顶点u出队。接下来不断从队列中取出新的队首节点再进行如上操作。直至队空为止。

4.具体步骤

1. 初始化图的邻接表，队列deq，和dis（存放1号顶点到其余各个顶点的最短路径），如下图：
   
2. 对deq的首节点1进行遍历。

deq首节点1遍历过程	结果判断
1—> 2,w = 2;（dis[2] = ∞）>（ (dis[1] = 0) + (w[2] = 2）== 2)	更新
1—> 5，w = 10;（dis[5] = ∞）>（ (dis[1] = 0) + (w[5] = 10）== 10)	更新

更新后的数据结构如下：

3. 对deq的首节点2进行遍历。

deq首节点2遍历过程	结果判断
2—> 3，w = 3;（dis[3] = ∞）<（ (dis[2] = 2) + (w[3] = 3）== 5)	否
2—> 5，w = 7;（dis[5] = 10）>（ (dis[2] = 2) + (w[5] = 7）== 9)	更新，但不入队列

更新后的数据结构如下：
4. 对deq的首节点5进行遍历。

deq首节点1遍历过程	结果判断
5—> 3，w = 6;（dis[3] = 5）<（ (dis[5] = 9) + (w[3] = 6）== 15)	否

更新后的数据结构如下：

4. 对deq的首节点3进行遍历。

deq首节点3遍历过程	结果判断
3—> 4，w = 4;（dis[4] = ∞）>（ (dis[3] = 5) + (w[4] = 4）== 9)	更新

更新后的数据结构如下：

5.对deq的首节点4进行遍历。

deq首节点4遍历过程	结果判断
4—> 5，w = 5;（dis[5] = 9）<（ (dis[4] = 9) + (w[4] = 5）== 14)	否

更新后的数据结构如下：

至此，所有数据均已更新完毕。

5.具体实现

在具体的实现过程中，顶点1，2，3，4，5存储在vector中，而vector[i]中的元素均为list，list由unordered_map组成，含义如下图：

#include <vector>
#include <iostream>
#include <list>
#include <queue>
#include <unordered_map>

using namespace std;

class Bellman_Ford_Que
{
private:
    int vertice = 0;//顶点数
    int edge = 0;//边数
    
    vector<int> dis;//源点到各个顶点之间的最短距离
    vector<bool> book;//记录那个节点已经被遍历过（队列中的所有节点）
    vector<list<unordered_map<int,int>>> e;//图的邻接表存储方法
    queue<int> que;


public:
    //根据节点值和边值初始化：边的起始节点数组u，边的终止节点数组v，边u[i]->v[i]的权重w
    Bellman_Ford_Que(int x, int y) :vertice(x), edge(y)
    {
        //图的初始化从下标1开始
        dis.resize(vertice + 1);        
        book.resize(vertice + 1);
        e.resize(vertice + 1);
    }
    
    //读入图的边，并且根据边的信息初始化数组dis，数组book
    void GetEdgeInfo()
    {
        cout << "输入边的信息（节点1，节点2，权重）：" << endl;
        int e1 = 0, e2 = 0, weigth = 0;
        for (int i = 1; i <= edge; i++)
        {
            cin >> e1 >> e2 >> weigth;
            unordered_map<int, int> map = { {e2,weigth} };
            e[e1].push_back(map);

        }
        for (int i = 2; i <= vertice; i++)
        {
            //dis[1]在构造函数里面已经初始化为0
            dis[i] = INT_MAX;
        }
        book[1] = true;
    }

    //打印
    void Print()
    {
        for (int i = 1; i <= vertice; i++)
        {

            cout << dis[i] << "    ";
        }
        cout << endl;
    }

    //Bellman_Ford核心思想
    void Bellman_Ford_Que_Alg()
    {
        que.push(1);
        while (!que.empty())//队列不为空的时候循环
        {
            int  ver = que.front();//队列的首元素
            
            auto it = e[ver].begin();
            
            while (it != e[ver].end())//扫描当前节点的所有边
            {
                auto temp = it->begin();
                if (dis[ver] < INT_MAX && dis[temp->first] > (dis[ver] + temp->second))
                {
                    dis[temp->first] = (dis[ver] + temp->second);

                }     
                if (book[temp->first] == 0)//顶点不在队列中
                {
                    que.push(temp->first);
                    book[temp->first] = 1;
                }
                it++;
            }

            que.pop();
        }
    }
};

int main()
{
    Bellman_Ford_Que Bellman(5, 7);
    Bellman.GetEdgeInfo();

    cout << "初始信息：" << endl;
    Bellman.Print();

    Bellman.Bellman_Ford_Que_Alg();

    cout << "单源最短路径(顶点1到其余各顶点)：" << endl;
    Bellman.Print();    

    return 0;
}

6.总结

简单来说，算法的具体思路是：初始时将源点加入队列。每次从队首取出一个顶点，并对与其相邻的所有顶点进行松弛操作，若某个相邻的顶点松弛成功且这个相邻的顶点不在队列中，则对当前顶点处理完毕后立即出队，并对新的队首元素进行如上操作，直到队列为空时算法结束。
用队列进行优化的关键在于：只有那些在前一遍松弛中改变了最短路径估计值的顶点，才可能引起他们邻接点最短路径发生改变。因此，用一个队列来存放被成功松弛的顶点，降低了算法复杂度。