【数据结构】图

图的基本概念

图是由顶点集合及顶点间的关系组成的一种数据结构

记作：$G=(V,E)$

其中：

• 顶点集合 V = { x ∣ x 属于某个数据对象集 } V = \{x | x属于某个数据对象集\} V={x∣x属于某个数据对象集}是有穷非空集合；

• E = { < x , y > ∣ x , y 属于 V } E = \{ \lt x,y\gt | x,y属于V \} E={<x,y>∣x,y属于V}或者 E = { < x , y > ∣ x , y 属于 V & & P a t h ( x , y ) } E = \{ \lt x, y\gt | x,y属于V \& \& Path(x, y)\} E={<x,y>∣x,y属于V&&Path(x,y)}是顶点间关系的有穷集合，也叫做边的集合。

  • $<x,y>$表示$x$到$y$的一条双向通路，即$x,y$是无方向的；
  • $Path(x,y)$表示从$x$到$y$的一条单向通路，即$Path(x,y)$是有方向的。

• 顶点和边：

  • 图中结点称为顶点，第$i$个顶点记作$v_i$。
  • 两个顶点$v_i$和$v_j$相关联称作顶点$v_i$和顶点$v_j$之间有一条边，图中的第$k$条边记作$e_k$，$e_k=(v_i,v_j)$或$e_k=<v_i,v_j>$。

• 有向图和无向图：

  • 在有向图中，顶点对$<x,y>$是有序的，顶点对$<x,y>$称为顶点$x$到顶点$y$的一条边(弧)，$<x,y>$和$<y,x>$是两条不同的边，比如图$G3$和$G4$为有向图。
  • 在无向图中，顶点对$(x,y)$是无序的，顶点对$(x,y)$称为顶点$x$和顶点$y$相关联的一条边，这条边没有特定方向，$(x,y)$和$(y,x)$是同一条边，比如图$G1$和$G2$为无向图。注意：无向边$(x,y)$等于有向边$<x,y>$和$<y,x>$。
    

• 完全图：

  • 在有$n$个顶点的无向图中，若有$n\ast (n-1)/2$条边，即任意两个顶点之间有且仅有一条边，则称此图为无向完全图，比如图$G1$；
  • 在$n$个顶点的有向图中，若有$n\ast (n-1)$条边，即任意两个顶点之间有且仅有方向相反的边，则称此图为有向完全图，比如图$G4$。

• 邻接顶点：

  • 在无向图$G$中，若$(u,v)$是$G$中的一条边，则称$u$和$v$互为邻接顶点，并称边$(u,v)$依附于顶点$u$和$v$；
  • 在有向图$G$中，若$<u,v>$是$G$中的一条边，则称顶点$u$邻接到$v$，顶点$v$邻接自顶点$u$，并称边$<u,v>$与顶点$u$和顶点$v$相关联。

• 顶点的度：顶点的度是指与它相关联的边的条数，记作$deg(v)$。

  • 在有向图中，顶点的度等于该顶点的入度与出度之和，其中：
    • 顶点的入度是以为$v$终点的有向边的条数，记作$indev(v)$；
    • 顶点$v$的出度是以为$v$起始点的有向边的条数，记作$outdev(v)$。
    • 因此：$dev(v)=indev(v)+outdev(v)$。
  • 注意：对于无向图，顶点的度等于该顶点的入度和出度，即$dev(v)=indev(v)=outdev(v)$。

• 路径：在图$G=(V,E)$中，若从顶点$v$出发有一组边使其可到达顶点$v_j$，则称顶点$v_i$到顶点$v_j$的顶点序列为从顶点$v_i$到顶点$v_j$的路径。

• 路径长度：

  • 对于不带权的图，一条路径的路径长度是指该路径上的边的条数；
  • 对于带权的图，一条路径的路径长度是指该路径上各个边权值的总和。权值：边附带的数据信息
    

• 简单路径与回路：

  • 若路径上各顶点$v_1,v_2,v_3,\dots ,v_m$均不重复，则称这样的路径为简单路径。
  • 若路径上第一个顶点$v_1$和最后一个顶点$v_m$重合，则称这样的路径为回路或环。
    

• 子图：设图$G=(V,E)$和图$G_1=(V_1,E_1)$，若$V_1$属于$V$且$E_1$属于$E$，则称$G_1$是$G$的子图。
  

• 连通图：在无向图中，若从顶点$v1$到顶点$v2$有路径，则称顶点$v1$与顶点$v2$是连通的。如果图中任意一对顶点都是连通的，则称此图为连通图。

• 强连通图：在有向图中，若在每一对顶点$v_i$和$v_j$之间都存在一条从$v_i$到$v_j$的路径，也存在一条从$v_j$到$v_i$的路径，则称此图是强连通图。

• 生成树：一个连通图的最小连通子图称作该图的生成树。有$n$个顶点的连通图的生成树有$n$个顶点和$n-1$条边。

图的存储结构

因为图中既有节点，又有边(节点与节点之间的关系)，因此，在图的存储中，只需要保存：节点和边关系即可。节点保存比较简单，只需要一段连续空间即可，那边关系该怎么保存呢？

邻接矩阵

因为节点与节点之间的关系就是连通与否，即为$0$或者$1$，因此邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系。

注意：

1. 无向图的邻接矩阵是对称的，第$i$行(列)元素之和，就是顶点$i$的度。有向图的邻接矩阵则不一定是对称的，第$i$行元素之和就是顶点$i$的出(入)度。
2. 如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个顶点不连通，则使用无穷大代替。
3. 用邻接矩阵存储图的有点是能够快速知道两个顶点是否连通，缺陷是如果顶点比较多，边比较少的，矩阵中存储了大量的$0$成为系数矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。

template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>
class Graph
{
public:
    typedef Graph<V, W, MAX_W, Direction> Self;

    Graph() = default;

    Graph(const V* vertexes, size_t n)
    {
        _vertexs.reserve(n);
        for (size_t i = 0; i < n; ++i)
        {
            _vertexs.push_back(vertexes[i]);
            _vIndexMap[vertexes[i]] = i;
        }

        // MAX_W 作为不存在边的标识值
        _matrix.resize(n);
        for (auto& e : _matrix)
        {
            e.resize(n, MAX_W);
        }
    }

    size_t GetVertexIndex(const V& v)
    {
        auto ret = _vIndexMap.find(v);
        if (ret != _vIndexMap.end())
        {
            return ret->second;
        }
        else
        {
            throw invalid_argument("不存在的顶点");
            return -1;
        }
    }

    void _AddEdge(size_t src_i, size_t dst_i, const W& w)
    {
        _matrix[src_i][dst_i] = w;
        if (Direction == false)
        {
            _matrix[dst_i][src_i] = w;
        }
    }

    void AddEdge(const V& src, const V& dst, const W& w)
    {
        size_t src_i = GetVertexIndex(src);
        size_t dst_i = GetVertexIndex(dst);

        _AddEdge(src_i, dst_i, w);
    }

    void Print()
    {
        // 打印顶点和下标映射关系
        for (size_t i = 0; i < _vertexs.size(); ++i)
        {
            cout << _vertexs[i] << "-" << i << " ";
        }
        cout << endl << endl;

        cout << "  ";
        for (size_t i = 0; i < _vertexs.size(); ++i)
        {
            cout << i << " ";
        }
        cout << endl;

        // 打印矩阵
        for (size_t i = 0; i < _matrix.size(); ++i)
        {
            cout << i << " ";
            for (size_t j = 0; j < _matrix[i].size(); ++j)
            {
                if (_matrix[i][j] != MAX_W)
                    cout << _matrix[i][j] << " ";
                else
                    cout << "#" << " ";
            }
            cout << endl;
        }
        cout << endl << endl;

        // 打印所有的边
        for (size_t i = 0; i < _matrix.size(); ++i)
        {
            for (size_t j = 0; j < _matrix[i].size(); ++j)
            {
                if (i < j && _matrix[i][j] != MAX_W)
                {
                    cout << _vertexs[i] << "-" << _vertexs[j] << ":" << _matrix[i][j] << endl;
                }
            }
        }
    }

private:
    map<V, size_t> _vIndexMap;
    vector<V> _vertexs;         // 顶点集合
    vector<vector<W>> _matrix;  // 存储边集合的矩阵
};

void TestGraph()
{
    Graph<char, int, INT_MAX, true> g("0123", 4);
    g.AddEdge('0', '1', 1);
    g.AddEdge('0', '3', 4);
    g.AddEdge('1', '3', 2);
    g.AddEdge('1', '2', 9);
    g.AddEdge('2', '3', 8);
    g.AddEdge('2', '1', 5);
    g.AddEdge('2', '0', 3);
    g.AddEdge('3', '2', 6);

    g.Print();
}

邻接表

邻接表：使用数组表示顶点的集合，使用链表表示边的关系。

1. 无向图邻接表存储
   

注意：无向图中同一条边在邻接表中出现了两次。如果想知道顶点vi的度，只需要知道顶点v_i边链表集合中结点的数目即可。

2. 有向图邻接表存储
   

注意：有向图中每条边在邻接表中只出现一次，与顶点vi对应的邻接表所含结点的个数，就是该顶点的出度，也称出度表，要得到v_i顶点的入度，必须检测其他所有顶点对应的边链表，看有多少边顶点的dst取值是i。

// 邻接表
namespace LinkTable
{
    template<class W>
    struct LinkEdge
    {
        int _srcIndex;
        int _dstIndex;
        W _w;
        LinkEdge<W>* _next;

        LinkEdge(const W& w)
            : _srcIndex(-1)
           , _dstIndex(-1)
           , _w(w)
           , _next(nullptr)
        {}
    };

    template<class V, class W, bool Direction = false>
    class Graph
    {
        typedef LinkEdge<W> Edge;
    public:
        Graph(const V* vertexes, size_t n)
        {
            _vertexs.reserve(n);
            for (size_t i = 0; i < n; ++i)
            {
                _vertexs.push_back(vertexes[i]);
                _vIndexMap[vertexes[i]] = i;
            }

            _linkTable.resize(n, nullptr);
        }

        size_t GetVertexIndex(const V& v)
        {
            auto ret = _vIndexMap.find(v);
            if (ret!= _vIndexMap.end())
            {
                return ret->second;
            }
            else
            {
                throw invalid_argument("不存在的顶点");
                return -1;
            }
        }

        void AddEdge(const V& src, const V& dst, const W& w)
        {
            size_t srcindex = GetVertexIndex(src);
            size_t dstindex = GetVertexIndex(dst);

            // 0 1
            Edge* sd_edge = new Edge(w);
            sd_edge->_srcIndex = srcindex;
            sd_edge->_dstIndex = dstindex;

            sd_edge->_next = _linkTable[srcindex];
            _linkTable[srcindex] = sd_edge;

            // 1 0
            // 无向图
            if (Direction == false)
            {
                Edge* ds_edge = new Edge(w);
                ds_edge->_srcIndex = dstindex;
                ds_edge->_dstIndex = srcindex;

                ds_edge->_next = _linkTable[dstindex];
                _linkTable[dstindex] = ds_edge;
            }
        }

    private:
        map<string, int> _vIndexMap;
        vector<V> _vertexs;          // 顶点集合
        vector<Edge*> _linkTable;    // 边的集合的邻接表
    };

    void TestGraph()
    {
        string a[] = { "张三", "李四", "王五", "赵六" };
        Graph<string, int> g1(a, 4);
        g1.AddEdge("张三", "李四", 100);
        g1.AddEdge("张三", "王五", 200);
        g1.AddEdge("王五", "赵六", 30);
    }
}

图的遍历

给定一个图G和其中任意一个顶点v₀，从v₀出发，沿着图中各边访问图中的所有顶点，且每个顶点仅被遍历一次。"遍历"即对结点进行某种操作的意思。

图的广度优先遍历

类比于二叉树层序遍历，但是问题：如何防止节点被重复遍历？：标记数组！

void BFS(const V& src)
{
    size_t srcindex = GetVertexIndex(src);
    
    vector<bool> visited;
    visited.resize(_vertexs.size(), false);

    queue<int> q;
    q.push(srcindex);
    
    visited[srcindex] = true;
    
    size_t d = 1;			//记录度
    size_t qsize = 1;		//队列q的大小
    
    while (!q.empty())
    {
        printf("%s的%d度好友:", src.c_str(), d);

        while (dsize--)
        {
            size_t front = q.front();
            q.pop();
            for (size_t i = 0; i < _vertexs.size(); ++i)
            {
                if (visited[i] == false && _matrix[front][i]!= MAX_W)
                {
                    printf("[%d:%s] ", i, _vertexs[i].c_str());
                    visited[i] = true;
                    q.push(i);
                }
            }
        }
        cout << endl;

        qsize = q.size();
        ++d;
    }
    cout << endl;
}

void TestGraphDBFS()
{
    string a[] = { "张三", "李四", "王五", "赵六", "周七" };
    Graph<string, int> g1(a, sizeof(a)/sizeof(string));
    g1.AddEdge("张三", "李四", 100);
    g1.AddEdge("张三", "王五", 200);
    g1.AddEdge("王五", "赵六", 30);
    g1.AddEdge("王五", "周七", 30);

    g1.BFS("张三");
    g1.DFS("张三");
}

图的深度优先遍历

类似于二叉树递归遍历

	void _DFS(size_t srci, vector<bool>& visited)
		{
			cout << srci << ":" << _vertexs[srci] << endl;
			visited[srci] = true;

			// 找一个srci相邻的没有访问过的点，去往深度遍历
			for (size_t i = 0; i < _vertexs.size(); ++i)
			{
				if (_matrix[srci][i] != MAX_W && visited[i] == false)
				{
					_DFS(i, visited);
				}
			}

		}

		void DFS(const V& src)
		{
			size_t srci = GetVertexIndex(src);
			vector<bool> visited(_vertexs.size(), false);

			_DFS(srci, visited);
		}

void _DFS(int index, vector<bool>& visited)
{
    if (!visited[index])
    {
        cout << _v[index] << " ";
        visited[index] = true;

        LinkEdge* pCur = _linkEdges[index];
        while (pCur)
        {
            _DFS(pCur->_dst, visited);
            pCur = pCur->_pNext;
        }
    }
}

void DFS(const V& v)
{
    cout << "DFS:";
    vector<bool> visited(_v.size(), false);
    _DFS(GetIndexOfv(v), visited);

    for (size_t index = 0; index < _v.size(); ++index)
        _DFS(index, visited);

    cout << endl;
}

void TestGraphDBFS()
{
    string a[] = { "张三", "李四", "王五", "赵六", "周七" };
    Graph<string, int> g1(a, sizeof(a) / sizeof(string));
    g1.AddEdge("张三", "李四", 100);
    g1.AddEdge("张三", "王五", 200);
    g1.AddEdge("王五", "赵六", 30);
    g1.AddEdge("王五", "周七", 30);


    g1.BFS("张三");
    g1.DFS("张三");
}

最小生成树

连通图中的每一棵生成树，都是原图的一个极大无环子图，即：

• 从其中删去任何一条边，生成树就不在连通；
• 反之，在其中引入任何一条新边，都会形成一条回路。

若连通图由n个顶点组成，则其生成树必含n个顶点和n - 1条边。因此构造最小生成树的准则有三条：

1. 只能使用图中的边来构造最小生成树
2. 只能使用恰好n - 1条边来连接图中的n个顶点
3. 选用的n - 1条边不能构成回路

构造最小生成树的方法：Kruskal算法和Prim算法。这两个算法都采用了逐步求解的贪心策略。

贪心算法：是指在问题求解时，总是做出当前看起来最好的选择。也就是说贪心算法做出的不是整体最优的的选择，而是某种意义上的局部最优解。贪心算法不是对所有的问题都能得到整体最优解。

Kruskal算法

任给一个有n个顶点的连通网络N = {V, E}

• 首先构造一个由这n个顶点组成、不含任何边的图G = {V, NULL}，其中每个顶点自成一个连通分量
• 其次不断从E中取出权值最小的一条边（若有多条任取其一），若该边的两个顶点来自不同的连通分量，则将此边加入到G中。
• 如此重复，直到所有顶点在同一个连通分量上为止。

核心：每次迭代时，选出一条具有最小权值，且两端点不在同一连通分量上的边，加入生成树。

kruskal(Self& minTree)
{
	//初始化minTree
    minTree._vertexs = _vertexs;
    minTree._vIndexMap = _vIndexMap;
    minTree._matrix.resize(_vertexs.size());
    for (auto& e : minTree._matrix)
    {
        e.resize(_vertexs.size(), MAX_W);
    }
    
	//根据图的权重初始化小根堆
    priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
    for (size_t i = 0; i < _matrix.size(); ++i)
    {
        for (size_t j = 0; j < _matrix[i].size(); ++j)
        {
            if (i < j && _matrix[i][j]!= MAX_W)
            {
                pq.push(Edge(i, j, _matrix[i][j]));
            }
        }
    }

    W total = W();//记录minTree的权重

	UnionFindSet ufs(_vertexs.size());//并查集，判断是否成环
    
	// 贪心算法，从最小的边开始选
    size_t i = 1;
    while (i < _vertexs.size() &&!pq.empty())
    {
        Edge min = pq.top();
        pq.pop();
        // 边不在一个集合，说明不会构成环，则添加到最小生成树
        if (ufs.FindRoot(min._src_i)!= ufs.FindRoot(min._dst_i))
        {
            //cout << _vertexs[min._src_i] << "-" << _vertexs[min._dst_i] << ":" << _matrix[min._src_i][min._dst_i] << endl;
            minTree._AddEdge(min._src_i, min._dst_i, min._w);
            total += min._w;

            ufs.Union(min._src_i, min._dst_i);
            ++i;
        }
    }

    if (i == _vertexs.size())
    {
        return total;
    }
    else
    {
        return W();
    }
}

void TestGraphMinTree()
{
    const char* str = "abcdefghi";
    Graph<char, int> g(str, strlen(str));
    g.AddEdge('a', 'b', 4);
    g.AddEdge('a', 'h', 8);
    //g.AddEdge('a', 'h', 9);
    g.AddEdge('b', 'c', 8);
    g.AddEdge('b', 'h', 11);
    g.AddEdge('c', 'i', 2);
    g.AddEdge('c', 'f', 4);
    g.AddEdge('c', 'd', 7);
    g.AddEdge('d', 'f', 14);
    g.AddEdge('d', 'e', 9);
    g.AddEdge('e', 'f', 10);
    g.AddEdge('f', 'g', 2);
    g.AddEdge('g', 'h', 1);
    g.AddEdge('g', 'i', 6);
    g.AddEdge('h', 'i', 7);

    Graph<char, int> kminTree;
    cout << "Kruskal:" << g.kruskal(kminTree) << endl;
    kminTree.Print();

    Graph<char, int> pminTree;
    cout << "Prim:" << g.Prim(pminTree, 'a') << endl;
    pminTree.Print();
}

Prim算法

w Prim(Self& minTree, const V& src)
{
    minTree._vertexs = _vertexs;
    minTree._vIndexMap = _vIndexMap;
    minTree._matrix.resize(_vertexs.size());
    for (auto& e : minTree._matrix)
    {
        e.resize(_vertexs.size(), MAX_W);
    }

    size_t srci = GetVertexIndex(src);


    set<size_t> inSet;//记录已统计的点
    inSet.insert(srci);

    priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
    for (size_t i = 0; i < _vertexs.size(); ++i)
    {
        if (_matrix[srci][i] != MAX_W)
        {
            pq.push(Edge(srci, i, _matrix[srci][i]));
        }
    }

    w total = w();
    while (inSet.size() < _vertexs.size() && !pq.empty())
    {
        Edge min = pq.top();
        pq.pop();

        // 防止环的问题
        if (inSet.find(min._srci) == inSet.end() || inSet.find(min._dsti) == inSet.end())
        {
            //cout << _vertexs[min._srci] << "-" << _vertexs[min._dsti] << ":" << _matrix[min._srci][min._dsti] << endl;

            minTree._AddEdge(min._srci, min._dsti, min._w);
            total += min._w;

            // 新入顶点的连接边进入队列
            for (size_t i = 0; i < _vertexs.size(); ++i)
            {
                if (_matrix[min._dsti][i] != MAX_W && inSet.find(i) == inSet.end())
                {
                    pq.push(Edge(min._dsti, i, _matrix[min._dsti][i]));
                }
            }

            inSet.insert(min._dsti);
        }
    }

    if (inSet.size() == _vertexs.size())
    {
        return total;
    }
    else
    {
        return w();
    }
}

void TestGraphMinTree()
{
    const char* str = "abcdefghi";
    Graph<char, int> g(str, strlen(str));
    g.AddEdge('a', 'b', 4);
    g.AddEdge('a', 'h', 8);


    //g.AddEdge('a', 'h', 9);
    g.AddEdge('b', 'c', 8);
    g.AddEdge('b', 'h', 11);
    g.AddEdge('c', 'i', 2);
    g.AddEdge('c', 'f', 4);
    g.AddEdge('c', 'd', 7);
    g.AddEdge('d', 'f', 14);
    g.AddEdge('d', 'e', 9);
    g.AddEdge('e', 'f', 10);
    g.AddEdge('f', 'g', 2);
    g.AddEdge('g', 'h', 1);
    g.AddEdge('g', 'i', 6);
    g.AddEdge('h', 'i', 7);

    Graph<char, int> kminTree;
    cout << "kruskal:" << g.kruskal(kminTree) << endl;
    kminTree.Print();

    Graph<char, int> pminTree;
    cout << "Prim:" << g.Prim(pminTree, 'a') << endl;
    pminTree.Print();
}

最短路径

最短路径问题：从在带权有向图G中的某一顶点出发，找出一条通往另一顶点的最短路径，最短也就是沿路径各边的权值总和达到最小。

单源最短路径–Dijkstra算法

单源最短路径问题：给定一个图G = (V，E)，求解结点s ∈ V到图中每个结点v ∈ V的最短路径。

Dijkstra算法就适用于解决带权重的有向图上的单源最短路径问题，同时算法要求图中所有边的权重非负。一般在求解最短路径的时候都是已知一个起点和一个终点，所以使用Dijkstra算法求解过后也就得到了所需起点到终点的最短路径。

针对一个带权有向图G，将所有结点分为两组S和Q，

• S是已经确定最短路径的结点集合，在初始时为空（初始时就可以将源节点s放入，毕竟源节点到自己的代价是0），
• Q为其余未确定最短路径的结点集合，

每次从Q中找出一个起点到该结点代价最小的结点u，将u从Q中移出，并放入S中，对u的每一个相邻结点v进行松弛操作。

松弛即对每一个相邻结点v，判断源节点s到结点u的代价与u到v的代价之和是否比原来s到v的代价更小，若代价比原来小则要将s到v的代价更新为s到u与u到v的代价之和，否则维持原样。

如此一直循环直至集合Q为空，即所有节点都已经查找过一遍并确定了最短路径，至于一些起点到达不了的结点在算法循环后其代价仍为初始设定的值，不发生变化。

Dijkstra算法每次都是选择V - S中最小的路径节点来进行更新，并加入S中，所以该算法使用的是贪心策略。

Dijkstra算法存在的问题是不支持图中带负权路径，如果带有负权路径，则可能会找不到一些路径的最短路径。

void Dijkstra(const V& src, vector<W>& dist, vector<int>& parentPath)
{
    size_t N = _vertexs.size();
    size_t srci = GetVertexIndex(src);

    // vector<W> dist,记录srci-其他顶点最短路径权值数组
    dist.resize(N, MAX_W);
    // vector<int> parentPath 记录srci-其他顶点最短路径父顶点数组
    parentPath.resize(N, -1);

    // 标记是否找到最短路径的顶点集合S
    vector<bool> S;
    S.resize(N, false);

    // srci的权值给一个最小值，方便贪心第一次找到这个节点
    dist[srci] = W();

    // N个顶点更新N次
    for (size_t i = 0; i < N; ++i)
    {
        // 贪心算法：srci到不在S中路径最短的那个顶点u
        W min = MAX_W;
        size_t u = srci;  //路径最短顶点
        
        for (size_t j = 0; j < N; ++j)
        {
            if (S[j] == false && dist[j] < min)
            {
                min = dist[j];
                u = j;
            }
        }
        S[u] = true;

        // 松弛算法：更新一遍u连接的所有边，看是否能更新出更短连接路径
        for (size_t k = 0; k < N; ++k)
        {
            // 如果srci->u + u->k 比 srci->k更短 则进行更新
            if (S[k] == false && _matrix[u][k] != MAX_W
                && dist[u] + _matrix[u][k] < dist[k])
            {
                dist[k] = dist[u] + _matrix[u][k];
                parentPath[k] = u;
            }
        }
    }
}

// 打印最短路径的逻辑算法
void PrintShortPath(const V& src, const vector<W>& dist, const vector<int>& parentPath)
{
    size_t N = _vertexs.size();
    size_t srci = GetVertexIndex(src);

    for (size_t i = 0; i < N; ++i)
    {
        if (i == srci)
            continue;

        vector<int> path;
        int parenti = i;
        
        while (parenti != srci)
        {
            path.push_back(parenti);
            parenti = parentPath[parenti];
        }
        path.push_back(srci);

        reverse(path.begin(), path.end());
        for (auto pos : path)
        {
            cout << _vertexs[pos] << "->";
        }

        cout << dist[i] << endl;
    }
}

void TestGraphDijkstra()
{
    const char* str = "syztx";
    Graph<char, int, INT_MAX, true> g(str, strlen(str));
    g.AddEdge('s', 't', 10);
    g.AddEdge('s', 'y', 5);
    g.AddEdge('y', 't', 3);
    g.AddEdge('y', 'x', 9);
    g.AddEdge('y', 'z', 2);
    g.AddEdge('z', 's', 7);
    g.AddEdge('z', 'x', 6);
    g.AddEdge('t', 'y', 2);
    g.AddEdge('t', 'x', 1);
    g.AddEdge('x', 'z', 4);


    vector<int> dist;
    vector<int> parentPath;
    g.Dijkstra('s', dist, parentPath);
    g.PrintShortPath('s', dist, parentPath);

    // 图中带有负权路径时，贪心策略则失效了。
    // 测试结果可以看到s->t->y之间的最短路径没更新出来
    /*const char* str = "sytx";
    Graph<char, int, INT_MAX, true> g(str, strlen(str));
    g.AddEdge('s', 't', 10);
    g.AddEdge('s', 'y', 5);
    g.AddEdge('t', 'y', -7);
    g.AddEdge('y', 'x', 3);

    vector<int> dist;
    vector<int> parentPath;
    g.Dijkstra('s', dist, parentPath);
    g.PrintShortPath('s', dist, parentPath);*/
}

单源最短路径–Bellman-Ford算法

Dijkstra算法只能用来解决正权图的单源最短路径问题，但有些题目会出现负权图。

这时这个算法就不能帮助我们解决问题了，而Bellman-Ford算法可以解决负权图的单源最短路径问题。

它的优点是可以解决有负权边的单源最短路径问题，而且可以用来判断是否有负权回路。

它也有明显的缺点，它的时间复杂度O(N*E)（N是点数，E是边数）普遍是要高于Dijkstra算法O(N²)的。

像这里如果我们使用邻接矩阵实现，那么遍历所有边的数量的时间复杂度就是O(N^3)，这里也可以看出来Bellman - Ford就是一种暴力求解更新。

bool BellmanFord(const V& src, vector<W>& dist, vector<int>& parentPath)
{
    size_t N = _vertexs.size();
    size_t srci = GetVertexIndex(src);

    // vector<W> dist,记录srci-其他顶点最短路径权值数组
    dist.resize(N, MAX_W);

    // vector<int> parentPath 记录srci-其他顶点最短路径父顶点数组
    parentPath.resize(N, -1);

    // 先更新srci->srci为最小值
    dist[srci] = W();

    for (size_t k = 0; k < N - 1; ++k)
    {
        bool exchange = false;
        for (size_t i = 0; i < N; ++i)
        {
            for (size_t j = 0; j < N; ++j)
            {
                // srci->i + i->j < srci->j 则更新路径及权值
                if (_matrix[i][j] != MAX_W
                    && dist[i] + _matrix[i][j] < dist[j])
                {
                    dist[j] = dist[i] + _matrix[i][j];
                    parentPath[j] = i;

                    exchange = true;
                }
            }
        }

        if (exchange == false)
            break;
    }

    for (size_t i = 0; i < N; ++i)
    {
        for (size_t j = 0; j < N; ++j)
        {
            // 检查有没有负权回路
            if (_matrix[i][j] != MAX_W
                && dist[i] + _matrix[i][j] < dist[j])
            {
                return false;
            }
        }
    }

    return true;
}

void TestGraphBellmanFord()
{
    const char* str = "syztx";
    Graph<char, int, INT_MAX, true> g(str, strlen(str));
    g.AddEdge('s', 't', 6);
    g.AddEdge('s', 'y', 7);
    g.AddEdge('y', 'z', 9);
    g.AddEdge('y', 'x', -3);
    g.AddEdge('z', 's', 2);
    g.AddEdge('z', 'x', 7);
    g.AddEdge('t', 'x', 5);
    g.AddEdge('t', 'y', 8);
    g.AddEdge('t', 'z', -4);

    g.AddEdge('x', 't', -2);

    vector<int> dist;
    vector<int> parentPath;
    if (g.BellmanFord('s', dist, parentPath))
    {
        g.PrinrtShotPath('s', dist, parentPath);
    }
    else
    {
        cout << "存在负权回路" << endl;
    }

    // 微调图结构，带有负权回路的测试
    //const char* str = "syztx";
    //Graph<char, int, INT_MAX, true> g(str, strlen(str));
    //g.AddEdge('s', 't', 6);
    //g.AddEdge('s', 'y', 7);
    //g.AddEdge('y', 'x', -3);
    //g.AddEdge('y', 'z', 9);
    //g.AddEdge('y', 'x', -3);
    //g.AddEdge('y', 's', 1); // 新增
    //g.AddEdge('z', 's', 2);
    //g.AddEdge('z', 'x', 7);
    //g.AddEdge('t', 'x', 5);
    //g.AddEdge('t', 'y', -8); // 更改
    //g.AddEdge('t', 'z', -4);
    //g.AddEdge('x', 't', -2);

    //vector<int> dist;
    //vector<int> parentPath;
    //if (g.BellmanFord('s', dist, parentPath))
    //{
    //    g.PrinrtShotPath('s', dist, parentPath);
    //}
    //else
    //{
    //    cout << "存在负权回路" << endl;
    //}
}

多源最短路径–Floyd-Warshall算法

Floyd-Warshall算法是解决任意两点间的最短路径的一种算法。

Floyd算法考虑的是一条最短路径的中间节点，即简单路径p={v₁,v₂,…,v_n}上除v1和vn的任意节点。

设k是p的一个中间节点，那么从i到j的最短路径p就被分成i到k和k到j的两段最短路径p₁，p₂。
p₁是从i到k且中间节点属于{1，2，…，k-1}取得的一条最短路径。p2是从k到j且中间节点属于{1，2，…，k-1}取得的一条最短路径。

路径p是从结点i到结点j的一条最短路径，结点k是路径p上编号最大的中间结点。路径p₁是路径p上从结点i到结点k之间的一段，其所有中间结点取自集合{1，2，…，k-1}。从结点k到结点j的路径p₂也遵守同样的规则

Floyd-Warshall算法的原理是动态规划。

设$D_{i,j,k}$为从i到j的只以{1…k}集合中的节点为中间节点的最短路径的长度。

1. 若最短路径经过点k，则$D_{i,j,k}=D_{i,k,k-1}+D_{k,j,k-1}$；
2. 若最短路径不经过点k，则$D_{i,j,k}=D_{i,j,k-1}$。

因此，$D_{i,j,k}=\min (D_{i,j,k-1},D_{i,k,k-1}+D_{k,j,k-1})$。

在实际算法中，为了节约空间，可以直接在原来空间上进行迭代，这样空间可降至二维。

即Floyd算法本质是三维动态规划，D[i][j][k]表示从i到j只经过0到k个点最短路径，然后建立起转移方程，然后通过空间优化，优化掉最后一维度，变成一个最短路径的迭代算法，最后即得到所以点的最短路。

void Floydwarshall(vector<vector<W>>& vvDist, vector<vector<int>>& vvParentPath)
{
    size_t N = _vertexs.size();
    vvDist.resize(N);
    vvParentPath.resize(N);

    // 初始化权值和路径矩阵
    for (size_t i = 0; i < N; ++i)
    {
        vvDist[i].resize(N, MAX_W);
        vvParentPath[i].resize(N, -1);
    }

    // 将直接相连的路径初始化
    for (size_t i = 0; i < N; ++i)
    {
        for (size_t j = 0; j < N; ++j)
        {
            if (_matrix[i][j] != MAX_W)
            {
                vvDist[i][j] = _matrix[i][j];
                vvParentPath[i][j] = i;
            }
            else
            {
                vvParentPath[i][j] = -1;
            }

            if (i == j)
            {
                vvDist[i][j] = 0;
                vvParentPath[i][j] = -1;
            }
        }
    }

    // 依次用顶点k作为中转点更新最短路径
    for (size_t k = 0; k < N; ++k)
    {
        for (size_t i = 0; i < N; ++i)
        {
            for (size_t j = 0; j < N; ++j)
            {
                // i->k + k->j 比 i->j前面更新的距离更短，则更新
                if (vvDist[i][k] != MAX_W && vvDist[k][j] != MAX_W && vvDist[i][k] + vvDist[k][j] < vvDist[i][j])
                {
                    vvDist[i][j] = vvDist[i][k] + vvDist[k][j];
                    vvParentPath[i][j] = vvParentPath[k][j];
                }
            }
        }

        // 打印权值和路径矩阵观察数据（部分代码被注释）
        //for (size_t i = 0; i < N; ++i)
        //{
        //    for (size_t j = 0; j < N; ++j)
        //    {
        //        if (vvDist[i][j] == MAX_W)
        //        {
        //            printf("%3c", '*');
        //        }
        //        else
        //        {
        //            printf("%3d", vvDist[i][j]);
        //        }
        //    }
        //    cout << endl;
        //}

        //for (size_t i = 0; i < N; ++i)
        //{
        //    for (size_t j = 0; j < N; ++j)
        //    {
        //        printf("%3d", vvParentPath[i][j]);
        //    }
        //    cout << endl;
        //}
        //cout << "==============================" << endl;
    }
}

void TestFloydwarshall()
{
    const char* str = "12345";
    Graph<char, int, INT_MAX, true> g(str, strlen(str));
    g.AddEdge('1', '2', 3);
    g.AddEdge('1', '3', 8);
    g.AddEdge('1', '5', -4);
    g.AddEdge('2', '4', 1);
    g.AddEdge('2', '5', 7);
    g.AddEdge('3', '2', 4);
    g.AddEdge('4', '1', 2);
    g.AddEdge('4', '3', -5);
    g.AddEdge('5', '4', 6);

    vector<vector<int>> vvDist;
    vector<vector<int>> vvParentPath;
    g.Floydwarshall(vvDist, vvParentPath);

    // 打印任意两点之间的最短路径
    for (size_t i = 0; i < strlen(str); ++i)
    {
        g.PrinrtShotPath(str[i], vvDist[i], vvParentPath[i]);
        cout << endl;
    }
}