【高阶数据结构】图 -- 详解

一、图的基本概念

图 是由顶点集合及顶点间的关系组成的一种数据结构：G = (V， E)。其中：
  • 顶点集合 V = {x | x属于某个数据对象集} 是有穷非空集合；
  • E = {(x,y) | x,y属于V} 或者 E = {<x, y> | x,y属于V && Path(x, y)} 是顶点间关系的有穷集合，也叫做边的集合。
  • (x, y) 表示 x 到 y 的一条双向通路，即 (x, y) 是无方向的；
  • Path(x, y) 表示从 x 到 y 的一条单向通路，即 Path(x, y) 是有方向的。

G：Graph（图），E：Edge（边）。

注意：

  • 树是一种特殊（无环联通）的图。
  • 图不一定是树。 
  • 树关注的是节点（顶点）中存的值；而图关注的是顶点和边的权值。
  • 树属于存储型结构，每个节点存储对应的值；而图属于表示型结构，表示某种场景。

【交通网络图】

  • 顶点：城市
  • 边：城市之间的一个关系（高铁距离、高铁价格、高铁时间、高速距离...）

【社交关系】

  • 顶点：人
  • 边：表示两个人是好友
  • 边权值：亲密度等

  • 强社交关系（微信、QQ 等关系 -> 无向图）
  • 弱社交关系、媒体社交（微博、抖音等关系 -> 有向图）

顶点和边：图中结点称为顶点，第 i 个顶点记作 vi。两个顶点 vi 和 vj 相关联称作顶点 vi 和顶点 vj 之间有一条边，图中的第 k 条边记作 ek，ek = (vi，vj) 或 <vi，vj>。

有向图和无向图：在有向图中，顶点对< 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 * (n-1)/2 条边，即任意两个顶点之间有且仅有一条边，则称此图为无向完全图，比如上图 G1；在 n 个顶点的有向图中，若有 n * (n-1) 条边，即任意两个顶点之间有且仅有方向相反的边，则称此图为有向完全图，比如上图 G4。

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

顶点的度：顶点 v 的度是指与它相关联的边的条数，记作 deg(v)。在有向图中，顶点的度等于该顶点的入度与出度之和，其中顶点 v 的入度是以 v 为终点的有向边的条数，记作 indev(v)；顶点 v 的出度是以 v 为起始点的有向边的条数，记作 outdev(v)。因此：dev(v) = indev(v) + outdev(v)。

注意 ：对于无向图，顶点的度等于该顶点的入度和出度，即 dev(v) = indev(v) = outdev(v)。

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

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

简单路径与回路：若路径上各顶点 v1，v2，v3，…，vm 均不重复，则称这样的路径为简单路径。若路径上第一个顶点 v1 和最后一个顶点 vm 重合，则称这样的路径为回路或环。

子图 ：设图 G = {V, E} 和图 G1 = {V1，E1}，若 V1 属于 V 且 E1 属于 E，则称 G1 是 G 的子图。（顶点和边都是原图的一部分）

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

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

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

二、图的存储结构

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

1、邻接矩阵

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

注意 ：
  1. 无向图的邻接矩阵是对称的（可以做压缩），第 i 行（列）元素之和，就是顶点 i 的度。有向图的邻接矩阵则不一定是对称的，第 i 行（列）元素之后就是顶点 i 的出（入）度。
  2. 如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个顶点不通，则使用无穷大代替。
  3. 用邻接矩阵存储图（适合稠密图）的优点是能够 快速知道（O(1)）两个顶点是否连通并取到权值 ，缺陷是如果顶点比较多，边比较少（稀疏图）时，矩阵中存储了大量的 0 成为系数矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。
  4. 相对而言，邻接矩阵不适合查找一个顶点连接的所有边（O(N)）。

【代码实现】

//Test.cpp
#include <iostream>
using namespace std;#include "Graph.h"int main()
{matrix::TestGraph1();return 0;
}
//Graph.h
#pragma once
#include <vector>
#include <map>// 邻接矩阵
namespace matrix
{template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>class Graph{public:// 图的创建// 1、IO输入 —— 不方便测试，在OJ中更适合// 2、图结构关系写到文件中，读取文件// 3、手动添加边Graph(const V* a, size_t n){_vertexs.reserve(n);for (size_t i = 0; i < n; i++){_vertexs.push_back(a[i]);_indexMap[a[i]] = i;}// MAX_W作为不存在边的标识值_matrix.resize(n);for (size_t i = 0; i < _matrix.size(); i++){_matrix[i].resize(n, MAX_W);}}size_t GetVertexIndex(const V& v){auto it = _indexMap.find(v);if (it != _indexMap.end()){return it->second;}else{//assert(false);throw invalid_argument("顶点不存在");return -1; //防止编译器检查返回值}}void AddEdge(const V& src, const V& dst, const W& w){size_t srci = GetVertexIndex(src);size_t dsti = GetVertexIndex(dst);_matrix[srci][dsti] = w;// 无向图if (Direction == false){_matrix[dsti][srci] = w;}}void Print(){// 打印顶点和下标的映射关系// 打印顶点for (size_t i = 0; i < _vertexs.size(); i++){cout << "[" << i << "]" << "->" << _vertexs[i] << endl;}cout << 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++){//cout << _matrix[i][j] << ' ';if (_matrix[i][j] == MAX_W){cout << "* ";}else{cout << _matrix[i][j] << ' ';}}cout << endl;}cout << endl;}private:vector<V> _vertexs;			// 顶点集合map<V, int> _indexMap;		// 顶点映射下标vector<vector<W>> _matrix;  // 邻接矩阵};void TestGraph1(){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();}
}

结果显示：

2、邻接表

邻接表：使用数组表示顶点的集合，使用链表表示边的关系。
  • 邻接表适合存储稀疏图，适合查找一个顶点连出去的边。 
  • 邻接表不适合确定两顶点之间是否相连和查看权值。

（1）无向图邻接表存储

 

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

（2）有向图邻接表存储

一般情况下，有向图存储一个出边表即可。

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

【总结】

邻接矩阵和邻接表相辅相成 ，各有优缺点的互补结构。

【代码实现】

//Test.cpp
#include <iostream>
using namespace std;#include "Graph.h"int main()
{link_table::TestGraph1();return 0;
}

//Graph.h
#pragma once
#include <vector>
#include <map>
#include <string>//邻接表
namespace link_table
{template<class W>struct Edge{int _dsti; //目标点的下标W _w;	   //权值Edge<W>* _next;Edge(int dsti, const W& w):_dsti(dsti),_w(w),_next(nullptr){}};template<class V, class W, bool Direction = false>class Graph{typedef Edge<W> Edge;public:Graph(const V* a, size_t n){_vertexs.reserve(n);for (size_t i = 0; i < n; i++){_vertexs.push_back(a[i]);_indexMap[a[i]] = i;}_tables.resize(n, nullptr);}size_t GetVertexIndex(const V& v){auto it = _indexMap.find(v);if (it != _indexMap.end()){return it->second;}else{//assert(false);throw invalid_argument("顶点不存在");return -1; //防止编译器检查返回值}}void AddEdge(const V& src, const V& dst, const W& w){size_t srci = GetVertexIndex(src);size_t dsti = GetVertexIndex(dst);// 1->2Edge* eg = new Edge(dsti, w);eg->_next = _tables[srci];_tables[srci] = eg;// 2->1if (Direction == false){Edge* eg = new Edge(srci, w);eg->_next = _tables[dsti];_tables[dsti] = eg;}}void Print(){// 打印顶点和下标的映射关系// 打印顶点for (size_t i = 0; i < _vertexs.size(); i++){cout << "[" << i << "]" << "->" << _vertexs[i] << endl;}cout << endl;for (size_t i = 0; i < _tables.size(); i++){cout << _vertexs[i] << "[" << i << "]->";Edge* cur = _tables[i];while (cur){cout << "[" << _vertexs[cur->_dsti] << ":" << cur->_dsti << ":" << cur->_w << "]->";cur = cur->_next;}cout << "nullptr" << endl;}}private:vector<V> _vertexs;			// 顶点集合map<V, int> _indexMap;		// 顶点映射下标vector<Edge*> _tables;		// 邻接表};void TestGraph1(){string a[] = { "张三", "李四", "王五", "赵六" };Graph<string, int, true> g1(a, 4);g1.AddEdge("张三", "李四", 100);g1.AddEdge("张三", "王五", 200);g1.AddEdge("王五", "赵六", 30);g1.Print();}
}

三、图的遍历

图的遍历针对的是图的顶点，而不是图的边。
给定一个图 G 和其中任意一个顶点 v0，从 v0 出发，沿着图中各边访问图中的所有顶点，且每个顶 点仅被遍历一次。“遍历” 即对结点进行某种操作的意思。
树以前是怎么遍历的，此处可以直接用来遍历图吗？为什么？

1、图的广度优先遍历（BFS）

如何防止节点被重复遍历？
void BFS(const V& src)
{size_t srci = GetVertexIndex(src);// 队列和标记数组queue<int> q;vector<bool> visited(_vertexs.size(), false);q.push(srci);visited[srci] = true;int levelSize = 1;size_t n = _vertexs.size();while (!q.empty()){// 一层一层出for (int i = 0; i < levelSize; i++){int front = q.front();q.pop();cout << front << ":" << _vertexs[front] << ' ';// 把front顶点的邻接顶点入队列for (size_t i = 0; i < n; i++){if (_matrix[front][i] != MAX_W){if (visited[i] == false){q.push(i);visited[i] = true;}}}}cout << endl;levelSize = q.size();}cout << endl;
}void TestBDFS()
{string a[] = { "张三", "李四", "王五", "赵六", "周七" };Graph<string, int> g1(a, sizeof(a) / sizeof(string));g1.AddEdge("张三", "李四", 100);g1.AddEdge("张三", "王五", 200);g1.AddEdge("王五", "赵六", 30);g1.AddEdge("王五", "周七", 30);g1.Print();g1.BFS("张三");
}

2、图的深度优先遍历（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 TestBDFS()
{string a[] = { "张三", "李四", "王五", "赵六", "周七" };Graph<string, int> g1(a, sizeof(a) / sizeof(string));g1.AddEdge("张三", "李四", 100);g1.AddEdge("张三", "王五", 200);g1.AddEdge("王五", "赵六", 30);g1.AddEdge("王五", "周七", 30);g1.Print();g1.DFS("张三");
}

四、最小生成树

最小生成树：构成生成树的所有边加起来的权值是最小的（最小成本让这 n 个点相连）。

连通图中的每一棵生成树，都是原图的一个极大无环子图，即：从其中删去任何一条边，生成树就不再连通；反之，在其中引入任何一条新边，都会形成一条回路。

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

  1. 只能使用图中权值最小的边来构造最小生成树。
  2. 只能使用恰好 n-1 条边来连接图中的 n 个顶点。
  3. 选用的 n-1 条边不能构成回路。
构造最小生成树的方法： Kruskal 算法和  Prim 算法。这两个算法都采用了逐步求解的 贪心 策略。
贪心算法：是指在问题求解时，总是做出当前看起来最好的选择。也就是说贪心算法做出的不是
整体最优的的选择，而是某种意义上的 局部最优解 。贪心算法不是对所有的问题都能得到整体最优解。

1、Kruskal 算法

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

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

struct Edge
{size_t _srci;size_t _dsti;W _w;Edge(size_t srci, size_t dsti, const W& w): _srci(srci), _dsti(dsti), _w(w){}bool operator>(const Edge& e) const{return _w > e._w;}
};W Kruskal(Self& minTree)
{size_t n = _vertexs.size();minTree._vertexs = _vertexs;minTree._indexMap = _indexMap;minTree._matrix.resize(n);for (size_t i = 0; i < n; i++){minTree._matrix[i].resize(n, MAX_W);}priority_queue<Edge, vector<Edge>, greater<Edge>> minque;for (size_t i = 0; i < n; i++){for (size_t j = 0; j < n; j++){if (i < j && _matrix[i][j] != MAX_W){minque.push(Edge(i, j, _matrix[i][j]));}}}// 选出n-1条边int size = 0;W totalW = W();UnionFindSet ufs(n);while (!minque.empty()){Edge min = minque.top();minque.pop();if (!ufs.InSet(min._srci, min._dsti)){cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;minTree._AddEdge(min._srci, min._dsti, min._w);ufs.Union(min._srci, min._dsti);size++;totalW += min._w;}else{cout << "构成环：";cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;}}if (size == n - 1) return totalW;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();
}

void Print()
{// 打印顶点和下标的映射关系// 打印顶点for (size_t i = 0; i < _vertexs.size(); i++){cout << "[" << i << "]" << "->" << _vertexs[i] << endl;}cout << endl;// 打印矩阵// 打印横下标cout << "  ";for (size_t i = 0; i < _vertexs.size(); i++){//cout << i << ' ';printf("%4d", i);}cout << endl;for (size_t i = 0; i < _matrix.size(); i++){cout << i << ' '; //打印竖下标for (size_t j = 0; j < _matrix[i].size(); j++){//cout << _matrix[i][j] << ' ';if (_matrix[i][j] == MAX_W){//cout << "* ";printf("%4c", '*');}else{//cout << _matrix[i][j] << ' ';printf("%4d", _matrix[i][j]);}}cout << endl;}cout << 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;}}}
}

2、Prim 算法

W Prim(Self& minTree, const W& src)
{size_t srci = GetVertexIndex(src);size_t n = _vertexs.size();minTree._vertexs = _vertexs;minTree._indexMap = _indexMap;minTree._matrix.resize(n);for (size_t i = 0; i < n; ++i){minTree._matrix[i].resize(n, MAX_W);}vector<bool> X(n, false);vector<bool> Y(n, true);X[srci] = true;Y[srci] = false;// 从X->Y集合中连接的边里面选出最小的边priority_queue<Edge, vector<Edge>, greater<Edge>> minq;// 先把srci连接的边添加到队列中for (size_t i = 0; i < n; ++i){if (_matrix[srci][i] != MAX_W){minq.push(Edge(srci, i, _matrix[srci][i]));}}cout << "Prim开始选边" << endl;size_t size = 0;W totalW = W();while (!minq.empty()){Edge min = minq.top();minq.pop();// 最小边的目标点也在X集合，则构成环if (X[min._dsti]){//cout << "构成环:";//cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;}else{minTree._AddEdge(min._srci, min._dsti, min._w);//cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;X[min._dsti] = true;Y[min._dsti] = false;size++;totalW += min._w;if (size == n - 1)break;for (size_t i = 0; i < n; ++i){if (_matrix[min._dsti][i] != MAX_W && Y[i]){minq.push(Edge(min._dsti, i, _matrix[min._dsti][i]));}}}}if (size == n - 1){return totalW;}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> pminTree;cout << "Prim:" << g.Prim(pminTree, 'a') << endl;pminTree.Print();cout << endl;for (size_t i = 0; i < strlen(str); ++i){cout << "Prim:" << g.Prim(pminTree, str[i]) << endl;}
}

五、最短路径

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

1、单源最短路径 —— 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>& pPath)
{size_t srci = GetVertexIndex(src);size_t n = _vertexs.size();dist.resize(n, MAX_W);pPath.resize(n, -1);dist[srci] = 0;pPath[srci] = srci;// 已经确定最短路径的顶点集合vector<bool> S(n, false);for (size_t j = 0; j < n; ++j){// 选最短路径顶点且不在S更新其他路径int u = 0;W min = MAX_W;for (size_t i = 0; i < n; ++i){if (S[i] == false && dist[i] < min){u = i;min = dist[i];}}S[u] = true;// 松弛更新u连接顶点v  srci->u + u->v <  srci->v  更新for (size_t v = 0; v < n; ++v){if (_matrix[u][v] != MAX_W && dist[u] + _matrix[u][v] < dist[v]){dist[v] = dist[u] + _matrix[u][v];pPath[v] = u;}}}
}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);
}

void TestGraphDijkstra()
{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);
}

图中带有负权路径时，上面的贪心策略就失效了，从测试结果可以看到 s->t->y 之间的最短路径没更新出来：

​​​​​​​

修改代码如下：

2、单源最短路径 —— 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>& pPath)
{size_t n = _vertexs.size();size_t srci = GetVertexIndex(src);// vector<W> dist,记录srci-其他顶点最短路径权值数组dist.resize(n, MAX_W);// vector<int> pPath 记录srci-其他顶点最短路径父顶点数组pPath.resize(n, -1);// 先更新srci->srci为缺省值dist[srci] = W();//cout << "更新边：i->j" << endl;// 总体最多更新n轮for (size_t k = 0; k < n; ++k){// i->j 更新松弛bool update = false;cout << "更新第:" << k << "轮" << endl;for (size_t i = 0; i < n; ++i){for (size_t j = 0; j < n; ++j){// srci->i + i->jif (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j]){update = true;cout << _vertexs[i] << "->" << _vertexs[j] << ":" << _matrix[i][j] << endl;dist[j] = dist[i] + _matrix[i][j];pPath[j] = i;}}}// 如果这个轮次中没有更新出更短路径，那么后续轮次就不需要再走了if (update == false)break;}// 还能更新就是带负权回路for (size_t i = 0; i < n; ++i){for (size_t j = 0; j < n; ++j){// srci->i + i->jif (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j]){return false;}}}return true;
}void TestGraphBellmanFord1()
{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.PrintShortPath('s', dist, parentPath);elsecout << "存在负权回路" << endl;
}void TestGraphBellmanFord2()
{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('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.PrintShortPath('s', dist, parentPath);elsecout << "存在负权回路" << endl;
}

 

3、多源最短路径 —— Floyd-Warshall 算法

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

Floyd 算法考虑的是一条最短路径的中间节点，即简单路径 p={v1, v2, …, vn} 上除 v1 和 vn 的任意节点。设 k 是 p 的一个中间节点，那么从i到j的最短路径 p 就被分成 i 到 k 和 k 到 j 的两段最短路径 p1，p2。p1 是从 i 到 k 且中间节点属于 {1, 2, …, k-1} 取得的一条最短路径。p2 是从 k 到 j 且中间节点属于 {1, 2, …, k-1} 取得的一条最短路径。

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

void FloydWarshall(vector<vector<W>>& vvDist, vector<vector<int>>& vvpPath)
{size_t n = _vertexs.size();vvDist.resize(n);vvpPath.resize(n);// 初始化权值和路径矩阵for (size_t i = 0; i < n; ++i){vvDist[i].resize(n, MAX_W);vvpPath[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];vvpPath[i][j] = i;}if (i == j){vvDist[i][j] = W();}}}// abcdef  a {} f ||  b {} c// 最短路径的更新：i-> {其他顶点} ->jfor (size_t k = 0; k < n; ++k){for (size_t i = 0; i < n; ++i){for (size_t j = 0; j < n; ++j){// k 作为的中间点尝试去更新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];// 要找的是跟j相连的上一个邻接顶点// 如果 k->j 直接相连，上一个点就是k，那么vvpPath[k][j]存的就是k// 如果 k->j 没有直接相连（k->...->x->j），vvpPath[k][j]存的就是xvvpPath[i][j] = vvpPath[k][j];}}}// 打印权值和路径矩阵观察数据for (size_t i = 0; i < n; ++i){for (size_t j = 0; j < n; ++j){if (vvDist[i][j] == MAX_W){//cout << "*" << " ";printf("%3c", '*');}else{//cout << vvDist[i][j] << " ";printf("%3d", vvDist[i][j]);}}cout << endl;}cout << endl;for (size_t i = 0; i < n; ++i){for (size_t j = 0; j < n; ++j){//cout << vvParentPath[i][j] << " ";printf("%3d", vvpPath[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.PrintShortPath(str[i], vvDist[i], vvParentPath[i]);cout << endl;}
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/835020.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

pdf编辑软件，四款软件让你轻松玩转PDF编辑！

pdf编辑软件，四款软件让你轻松玩转PDF编辑！

在信息爆炸的当今时代&#xff0c;PDF格式文档因其跨平台、不易被篡改的特性而深受大家喜爱。然而&#xff0c;如何高效地编辑PDF文档却成为许多人的难题。今天&#xff0c;我将为大家推荐四款实用的PDF编辑软件&#xff0c;让你轻松玩转PDF编辑&#xff0c;告别繁琐操作&#…
阅读更多...
Springboot集成Mybatispuls操作mysql数据库-04

Springboot集成Mybatispuls操作mysql数据库-04

MyBatis-Plus&#xff08;简称MP&#xff09;是一个MyBatis的增强工具&#xff0c;在MyBatis的基础上只做增强而不做改变。它支持所有MyBatis原生的特性&#xff0c;因此引入MyBatis-Plus不会对现有的MyBatis构架产生任何影响。MyBatis-Plus旨在简化开发、提高效率&#xff0c;…
阅读更多...
【机器学习与实现】线性回归分析

【机器学习与实现】线性回归分析

目录 一、相关和回归的概念&#xff08;一&#xff09;变量间的关系&#xff08;二&#xff09;Pearson&#xff08;皮尔逊&#xff09;相关系数 二、线性回归的概念和方程&#xff08;一&#xff09;回归分析概述&#xff08;二&#xff09;线性回归方程 三、线性回归模型的损…
阅读更多...
3D Gaussian Splatting for Real-Time Radiance Field Rendering 论文阅读

3D Gaussian Splatting for Real-Time Radiance Field Rendering 论文阅读

如此热门的项目&#xff0c;网络上有很多大牛分析了这篇文章的做法&#xff0c;在这里简单记录一下个人粗浅的理解。 关于各种数学表达式的推导&#xff0c;论文和参考资料中都提供了较为详细的解读&#xff0c;本人能力有限&#xff0c;这一部分理解不够深刻&#xff0c;先不做…
阅读更多...
【CSDN搜材料的小技巧】怎么快速查到高质量最新的内容

【CSDN搜材料的小技巧】怎么快速查到高质量最新的内容

问题描述: 我最近搜CSDN已经搜累了&#xff0c;好多东西明显是有问题的&#xff0c;还有一堆人复制粘贴&#xff0c;从海量文章中提取出最新且高质量文章成了当务之急&#xff01; 解决方案: 我本来想写个爬虫按照文章的收藏或者点赞排序的&#xff0c;无意中看到了这篇文章…
阅读更多...
多线程三种实现

多线程三种实现

多线程 线程 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中&#xff0c;是进程中的实际运作单位。 &#xff08;理解&#xff1a;应用软件中互相独立&#xff0c;可以同时运行的功能&#xff09; 进程 进程是程序的基本执行实体。&#xff08;理解&#…
阅读更多...
在windows下安装wsl子系统

在windows下安装wsl子系统

一、安装环境 windows规格 版本Windows 10企业版版本号22H2操作系统内部版本19045.4291 二、安装过程 2.1 以管理员身份打开PowerShell&#xff08;win X快捷键&#xff09;&#xff1b; 2.2 输入命令&#xff1a;wsl --list --online&#xff08;简写&#xff1a;wsl -l …
阅读更多...
探索 Joomla! CMS：打造个性化网站的利器

探索 Joomla! CMS：打造个性化网站的利器

上周我们的Hostease客户咨询建站服务。他想要用Joomla建站。Hostease提供免费安装Joomla CMS服务。这可以让客户搭建网站变得更加简单和高效。下面是针对Joomla建站的一些使用心得。 Joomla CMS是一款开放自由的软件&#xff0c;为用户提供了创建和维护网站的自由度。它经过全…
阅读更多...
鸿蒙应用开发DevEco Studio工程目录模块介绍

鸿蒙应用开发DevEco Studio工程目录模块介绍

面向开发者&#xff0c;HarmonyOS 推出了 DevEco Studio 和 Dev Device Tool 两款开发工具&#xff0c;前者目前迭代至 3.1 版本&#xff08;对外开放版本&#xff09;&#xff0c;用于开发 HarmonyOS 应用&#xff1b;后者用于开发智能设备 应用的工程主体结构如上图 在这里我…
阅读更多...
编写一个C#程序，实现音乐文件的播放功能

编写一个C#程序，实现音乐文件的播放功能

一、作业要求 要求1&#xff1a; 1. 程序应能够读取MP3文件&#xff0c;并播放其中的音频。 2. 程序应能够处理可能出现的异常&#xff0c;如文件不存在、文件读取错误等。 3. 程序应具有良好的用户界面&#xff0c;方便用户进行操作。 4. 程序应具有良好的兼容性&#xf…
阅读更多...
数据可视化训练第三天(富豪借钱问题可视化)

数据可视化训练第三天(富豪借钱问题可视化)

题目 一个穷人到富人那里去借钱&#xff0c;原以为富人不愿意&#xff0c;哪知富人一口答应了下来&#xff0c; 但提出了如下条件&#xff1a; 在30天中&#xff0c;富人第一天借给穷人1万元&#xff0c;第二天借给2万&#xff0c;以后每天所借的钱数都比上一天的多一万&…
阅读更多...
C++数据结构——AVL树

C++数据结构——AVL树

前言&#xff1a;本篇文章将紧随二叉搜索树的节奏&#xff0c;分享一个新的数据结构——AVL树。 目录 一.AVL树概念 二.AVL树插入规则 三.AVL树实现 1.基本框架 2.插入 3.旋转 1&#xff09;左\右单旋 2&#xff09;左右/右左双旋 4.遍历 5.求树高度 6.判断平衡 7.…
阅读更多...
仿真算法验证成功后，如何快速实现真机无缝切换？

仿真算法验证成功后，如何快速实现真机无缝切换？

Prometheus仿真优势 首先&#xff0c;我们先通过下面这个视频了解一下Prometheus仿真有哪些优势&#xff1a; 开源自主无人机平台重大更新&#xff01;Promethus仿真到真机无缝切换 Prometheus仿真最大的优势之一是采用了模块化设计&#xff0c;对每个操作节点进行了封装&…
阅读更多...
影刀进行shopee商品排名零代码爬取

影刀进行shopee商品排名零代码爬取

需要研究shopee平台的排名更新时间段和周期&#xff0c;几分钟用影刀写了一个爬取应用&#xff0c;每10分钟进行一次排名爬取&#xff08;以fan‘风扇’为例&#xff09;&#xff0c;0代码爬取。 打开’fan’关键词搜索网页&#xff1b;等待网页加载&#xff1b;滚动进一步加载…
阅读更多...
如何使用Python为Excel文件添加预设文档属性和自定义文档属性

如何使用Python为Excel文件添加预设文档属性和自定义文档属性

向Excel文件添加文档属性是专业地组织和管理电子表格数据的关键步骤。这些属性&#xff0c;如标题、作者、主题和关键词&#xff0c;增强了文件的元数据&#xff0c;使得在大型数据库或文件系统中跟踪、排序和搜索文档变得更加容易。通过包含这些信息&#xff0c;您不仅提高了文…
阅读更多...
太牛了！360大佬编写的《应急响应指导手册》火了！（PDF限时3天领取）

太牛了！360大佬编写的《应急响应指导手册》火了！（PDF限时3天领取）

免责声明&#xff1a; 请使用者遵守《中华人民共和国网络安全法》&#xff0c;由于传播、利用本账号所提供的信息而造成的任何直接或者间接的后果及损失&#xff0c;均由使用者本人负责&#xff0c;公众号及作者不为此承担任何责任。 简介 这份《应急响应指导手册》&#xf…
阅读更多...
CSS跳动文字

CSS跳动文字

<div class"loading-mask"><div class"loading-text"><span style"--i:1">加</span><span style"--i:2">载</span><span style"--i:3">中</span><span style"--i:…
阅读更多...
android进阶-AIDL

android进阶-AIDL

参考&#xff1a;Android进阶——AIDL详解_android aidl-CSDN博客 AIDL&#xff08;Android 接口定义语言&#xff09;&#xff0c;可以使用它定义客户端与服务端进程间通信&#xff08;IPC&#xff09;的编程接口&#xff0c;在 Android 中&#xff0c;进程之间无法共享内存&…
阅读更多...
Word设置代码块格式

Word设置代码块格式

前言 Word中无法像Markdown和LaTeX一样插入代码块&#xff0c;若要在Word中插入代码块可以手动设置代码块格式或自动粘贴代码块格式。若不追求完美高亮效果&#xff0c;可使用前者方案&#xff1b;若追求完美的高亮效果&#xff0c;可使用后者方案。下文介绍这2种方案。 手动…
阅读更多...
C++ 多态的相关问题

C++ 多态的相关问题

目录 1. 第一题 2. 第二题 3. inline 函数可以是虚函数吗 4. 静态成员函数可以是虚函数吗 5. 构造函数可以是虚函数吗 6. 析构函数可以是虚函数吗 7. 拷贝构造和赋值运算符重载可以是虚函数吗 8. 对象访问普通函数快还是访问虚函数快 9. 虚函数表是什么阶段生成的&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023