中级数据结构：图

图的基本概念

本文所有算法都是在邻接矩阵实现。

• 图是由顶点集合及顶点间的关系组成的一种数据结构：G = (V， E)，其中：顶点集合V = {x|x属于某个数据对象集} 是有穷非空集合；V（vertex，顶点），E（Edge，边）。
• 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)是有方向的。

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

顶点集合、边、权值

• 顶点集合：例如可以表示城市的集合等；
• 边：例如城市之间有没有通高铁；
• 权值：两个城市之间的高铁票价、高铁里程等；
  

无向图 | 有向图 | 完全图

无向图

• 在无向图中，顶点对(x，y)是无序的，顶点对(x，y)称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x，y)和(y，x)是同一条边，比如下图G1和G2为无向图。注意：无向边(x， y)等于有向边<x，y>和<y， x>。
  • 树是一种特殊的无环连通的图，图不一定是树。
  • 树关注的是结点（顶点）中存的值；图关注的是顶点以及边的权值。
• 微信、qq等强社交关系，就是无向图；你是我的好友，那我也是你的好友。
  

有向图

• 在有向图中，顶点对<x， y>是有序的，顶点对<x，y>称为顶点x到顶点y的一条边(弧)，<x， y>和<y， x>是两条不同的边，比如下图G3和G4为有向图。
• 微博，抖音等关系，就是有向图，弱社交关系、媒体社交，我关注了你，你不一定关注我。

完全图

• 在有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 条边。

  • 最小连通子图：用最少的边连通。
    

• 最小生成树：再把权值带上。例如：城市之间修高铁，用最小的成本修建。意味着在一个连通图里选最少的边连通。

图的存储结构

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

邻接矩阵

• 因为节点与节点之间的关系就是连通与否，即为0或者1，因此邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系。
• 邻接矩阵O（1）判断两个顶点的连接关系，并取到权值。

邻接表

• 使用数组表示顶点的集合，使用链表表示边的关系。
• 一般情况下有向图，存一个出边表即可；
• 适合查找一个顶点连接出去的边。

稠密图与稀疏图

• 有很少条边或弧的图称为稀疏图，反之称为稠密图。图的存储结构：稠密图与稀疏图 对应 邻接矩阵与邻接表
• 这里稀疏和稠密是模糊的概念，都是相对而言的。目前为止还没有给出一个量化的定义。
  • 比方说一个有100个顶点、99条边的图，与100个顶点组成的有向完全图相比，他的边很少，也就是所谓的稀疏了。
• 稠密图用邻接矩阵存储；
• 稀疏图用 邻接表存储；

邻接矩阵 | 代码

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

• 无向图，有向图保存方式一致。
  
  

注意

• 无向图的邻接矩阵是对称的，第 i 行(列)元素之和，就是顶点 i 的度。有向图的邻接矩阵则不一定是对称的，第 i 行(列)元素之后就是顶点 i 的出(入)度。

• 如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个顶点不通，则使用无穷大代替。
  

• 用邻接矩阵存储图的有点是能够快速知道两个顶点是否连通，缺陷是如果顶点比较多，边比较少时，矩阵中存储了大量的0成为系数矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。

代码导游

• 模板参数列表：template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>
  • bool模板类型参数，false代表无向图；true代表有向图。
  • W权值模板类型；W权值的非类型模板参数一般用整形的最大值表示。
  • V顶点类型
• 需要的数据结构
  • 顶点集合： vector<V> _vertexs;
  • 顶点映射下标 ：map<V, int> _indexmap;
  • 邻接矩阵：vector<vector<W>> _matrix;
• 图的构造，用顶点集合构造。
• 功能：手动添加边：给一个起始顶点，目的顶点，两个顶点的权值。
  • 获取顶点的下标
• 图的显示打印，测试用。

代码

#include<iostream>
#include<climits>
#include<vector>
#include<map>

using namespace std;

//邻接矩阵
namespace matrix
{
	template<class V,class W,W MAX_W = INT_MAX,bool Direction = false>
	class Graph
	{
	private:
		vector<V> _vertexs; 		//顶点集合
		map<V, int> _indexmap; 		//顶点映射下标 
		vector<vector<W>> _matrix; 	//邻接矩阵

	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;//映射关系
			}
			//邻接矩阵：二维数组初始化弄好
			_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
			{
				throw invalid_argument("顶点不存在");
				return -1; //虽然抛异常了但仍需要返回，编译器不在乎运行逻辑，只在乎语法问题
				//断言在release 版本下，被频闭掉。
			}
		}

		//添加边的关系 也就是对二维数组的赋值，需要先获取顶点对应的下标
		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++)
				{
					if (_matrix[i][j] == MAX_W)
					{
						cout << "#" << " ";
					}
					else
					{
						cout << _matrix[i][j] << " ";
					}
				}
				cout << endl;
			}
			cout << endl;
		}
	};

---//测试
	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 的度，只需要知道顶点 vi 边链表集合中结点的数目即可。

2. 有向图邻接表存储

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

代码

namespace link_table {
	template<class W>
	struct Edge
	{
		int _dsti;	//目的顶点下标
		W _w;		//权值
		Edge* _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;
	private:
		vector<V> _vertexs;			// 顶点集合
		map<V, int> _indexMap;		// 顶点映射下标
		vector<Edge*> _tables;		// 邻接表
	public:
		Graph(const V* a, size_t n)			//用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);  //开辟N个大小的指针数组
		}

		size_t GetVertexIndex(const V& v)
		{
			auto it = _indexMap.find(v);
			if (it != _indexMap.end())
			{
				return it->second;
			}
			else
			{
				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->2
			Edge* eg = new Edge(dsti, w);
			eg->_next = _tables[srci];		//头插
			_tables[srci] = eg;

			// 2->1
			if (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) //_table[1,2,3..]每个单链表的打印
			{
				cout << _vertexs[i] << "[" << i << "]->";
				Edge* cur = _tables[i];
				while (cur)
				{					//目的坐标的顶点					
					cout << "[" << _vertexs[cur->_dsti] << ":" << cur->_dsti << ":" << cur->_w << "]->";
					cur = cur->_next;
				}
				cout << "nullptr" << endl;
			}
		}
	};

---//测试
	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 出发，沿着图中各边访问图中的所有顶点，且每个顶点仅被遍历一次。“遍历” 即对结点进行某种操作的意思。

• 分为：图的广度优先遍历（broad-first search）；图的深度优先遍历（deep-first search）。
• 本文都是在上文中的邻接矩阵中实现两种遍历。

图的广度优先遍历

• 类似于二叉树的层序遍历
  • 一个节点出队列时，把其邻接顶点入队列。
  • 要保证入队列的顶点没有出现过。
    

代码：

		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;

			size_t n = _vertexs.size();
			while (!q.empty())
			{
				int front = q.front();
				q.pop();
				//访问头部顶点
				cout << front << ":" << _vertexs[front] << endl;

				//front的邻接顶点入队列
				for (size_t i = 0; i < n; i++)
				{
					if (_indexmap[front][i] != MAX_W)
					{
						if (visited)
						{
							q.push(i);
							visited[i] = true;
						}
					}
				}
			}
		}

美团一道面试题：给定一个图，一个顶点，求出该顶点的6度好友。

• 邻接矩阵中：广度优点遍历一层一层的出。

		void BFS1(const V& src)
		{
			size_t srci = GetVertexIndex(src);

			//队列 和 标记数组
			queue<int> q;
			vector<bool> visited(_vertexs.size(), false);

			q.push(srci);
			visited[srci] = true;

			size_t n = _vertexs.size();
			size_t d = 1;
			while (!q.empty())
			{
				printf("%s的%d度好友:", src.c_str(), d);
				int levelsize = 1;
				for (size_t i = 0; i < levelsize; i++)
				{
					int front = q.front();
					q.pop();
					//访问头部顶点
					cout << front << ":" << _vertexs[front] << endl;

					//front的邻接顶点入队列
					for (size_t i = 0; i < n; i++)
					{
						if (_indexmap[front][i] != MAX_W)
						{
							if (visited)
							{
								q.push(i);
								visited[i] = true;
							}
						}
					}
				}
				cout << endl;  //一层出完了 出下一层
				levelsize = q.size();
				++d;
			}
		}

图的深度优先遍历

一个起点，沿着一条边走到头，再返回走其他边，以此访问完图中的所有顶点。

代码：

		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);
		}

• 若给的图不是连通图，有一部分顶点没有遍历完；则在 visited 标记数组中寻找没有遍历过的顶点，进行遍历。

最小生成树

1. 生成树：无向连通图中用最少的边将所有的顶点连通起来。最少的边有规定 n（个顶点）-1 条边。最小把边的权值带上。

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

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

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

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

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

Kruskal算法 | 代码

克鲁斯卡尔算法。

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

首先构造一个由这n个顶点组成、不含任何边的图G={V,NULL}，其中每个顶点自成一个连通分量，

其次不断从E中取出权值最小的一条边(若有多条任取其一)，若该边的两个顶点来自不同的连通分量，则将此边加入到G中。如此重复，直到所有顶点在同一个连通分量上为止。

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

需要解决：

• 如何表示边？
  • 结构体
• 如何在所有边里面找出最小的 n-1 条边？
  • 优先级队列
• 如何解决环的问题？
  • 并查集

代码：

• 一个输入输出行参数：minTree 图
• 返回值：n-1 条边权值的总和。

Kruskal算法

		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& e1)const
			{
				return _w > e1._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])); //二维数组中有效的数据push到优先级队列里
						//且因为矩阵对称无向图，只需插入一半即可。
					}
				}
			}
			
		---	//选出n-1条边
			int size1 = 0;
			W total = W();

			Union_Set ufs(n);//并查集解决环问题

			while (!minque.empty())
			{
				Edge mineg = minque.top();
				minque.pop();

				//合并srci 和 dsti ，如果在一个集合里则该边不能加入到生成树里
				if (!ufs.InSet(mineg._srci, mineg._dsti))
				{
					cout << _vertexs[mineg._srci] << "->" << _vertexs[mineg._dsti] <<":"<<mineg._w << endl;
					mintree._AddEdge(mineg._srci, mineg._dsti, mineg._w);
					ufs.Union(mineg._srci, mineg._dsti);
					++size1;
					total += mineg._w;
				}
				
			}
			if (size1 == n - 1)
			{
				return total;
			}
			else
			{
				return  W();
			}

		}
----//添加边的改造
		//添加边的关系
		void _AddEdge(size_t srci, size_t dsti, const W& w)  //下标 权值
		{
			_matrix[srci][dsti] = w;
			//无向图
			if (Direction == false)
			{
				_matrix[dsti][srci] = w;
			}
		}

		void AddEdge(const V& src, const V& dst, const W& w)  //顶点，权值
		{
			size_t srci = GetVertexIndex(src);
			size_t dsti = GetVertexIndex(dst);

			_AddEdge(srci, dsti, 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('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();
		cout << endl << endl;
	}

一些解释

• mintree图的初始化：每次选出来的最小边要往图中添加。
• 优先级队列（默认大堆less），边的仿函数（建成小堆greater）。
• 队列中最小边中两个顶点若在一个集合中，说明有环，不采用。
• 对邻接矩阵添加边的改造
  • Kruskal算法得到优先级队列中权值最小的边，里面存的都是顶点的下标。

Prim算法 | 代码

解决：

• 如何表示一个顶点在这个集合，不在那个集合？
  • 两个vector<bool> ，直接定址标记顶点在哪个集合；true or false
• 如何快速筛选出两个集合中的顶点所匹配出来的 边中权值最小，且不会构成环的 边？
  • 先将给的顶点所关联的边入优先级队列。
  • 取队列的 top，判断 top 边中 目标顶点是不是和 srci 顶点在一个集合中；不是则加入到最小生成树中
  • 再将目标顶点所关联的边加入到 优先级队列中；同时确保目标顶点所关联边的顶点还在 未加入到 最小生成树的那个集合中。

代码：

		W Prim(Self& mintree, const V& src)
		{
			size_t n = _vertexs.size();
			size_t srci = GetVertexIndex(src);

			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);
			}

			//X,Y集合
			vector<bool> X(n, false);
			vector<bool> Y(n, true);
			X[srci] = true;
			Y[srci] = false;

			priority_queue<Edge, vector<Edge>, greater<Edge>> minque;
			//先把srci相关的边加入到队列中
			for (size_t i = 0; i < n; i++)
			{
				if (_matrix[srci][i] != MAX_W)
				{
					minque.push(Edge(srci, i, _matrix[srci][i]));
				}
			}
			int size1 = 0; //记录选出多少条边
			W total = W(); //总的权值
			//开始选边
			while (!minque.empty())
			{
				Edge minEg = minque.top();
				minque.pop();

				if (!X[minEg._dsti]) //目的顶点不在x集合中则添加到最小生成树中。
				{
					mintree._AddEdge(minEg._srci, minEg._dsti, minEg._w);
					cout << _vertexs[minEg._srci] << "->" << _vertexs[minEg._dsti] << ":" << minEg._w << endl;
					
					//添加完毕修改目标顶点的所属集合
					X[minEg._dsti] = true;
					Y[minEg._dsti] = false;

					++size1;
					total += minEg._w;

					if (size1 == n-1)
					{
						break;  //避免n-1条边已经选出来而循环还在继续。
					}
					//添加目标顶点相关的边
					for (size_t i = 0; i < n; i++)
					{
						if (_matrix[minEg._dsti][i] != MAX_W && Y[i])
						{
							minque.push(Edge(minEg._dsti, i, _matrix[minEg._dsti][i]));
						}
					}
				}
			}
			if (size1 == n - 1)  //边多了或少了 取决于传的图
			{
				return total;
			}
			else
			{
				return W();
			}
		}

• 测试代码同上：
  

最短路径

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

• 经典的算法有：

  • 单源最短路径–Dijkstra算法
  • 单源最短路径–Bellman-Ford算法
  • 多源最短路径-- Floyd-Warshall算法

• 单源：一个起点到其他任意一点的最短路径。

• 多源：图中任意两点。

单源最短路径–Dijkstra算法

迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。

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

2. 针对一个带权有向图G，将所有结点分为两组S和Q，S是已经确定最短路径的结点集合，在初始时为空（初始时就可以将源节点s放入，毕竟源节点到自己的代价是0），Q 为其余未确定最短路径的结点集合，每次从Q 中找出一个起点到该结点代价最小的结点u ，将u 从Q 中移出，并放入S 中，对u 的每一个相邻结点v 进行松弛操作。

3. 松弛即对每一个相邻结点v ，判断源节点s到结点u 的代价与u 到v 的代价之和是否比原来s 到v 的代价更小，若代价比原来小则要将s 到v 的代价（权值、最短路径）更新为s 到u 与u 到v 的代价之和，否则维持原样。如此一直循环直至集合Q 为空，即所有节点都已经查找过一遍并确定了最短路径，至于一些起点到达不了的结点在算法循环后其代价仍为初始设定的值，不发生变化。Dijkstra算法每次都是选择V-S中最小的路径节点来进行更新，并加入S中，所以该算法使用的是贪心策略。

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

例子图解

• 初始图：
  

• 过程图：
  

如何用代码表示上述过程：存储并更新权值、存储最短路径及其集合呢？

• const V& src, vector<W>& dist, vector<int>& parentPath：已知会给一个起点。
  • vector<W> dist：记录srci->其他顶点最短路径权值数组。
  • vector<int> parentPath ：记录srci-> 其他顶点最短路径父顶点数组。

图解：

代码实现：

---//邻接矩阵
private:
		vector<V> _vertexs; //顶点集合
		map<V, int> _indexmap; //顶点映射下标 
		vector<vector<W>> _matrix; //邻接矩阵


		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;     //原点到自己的距离（权值）是0
			pPath[srci] = srci; //原点自己的下标就是pPath

			//每一步已经确定最短路径的顶点集合
			vector<bool> S(n, false); //起初一个点也没有。

			for (size_t j = 0; j < n; j++) //总共N个顶点 更新n次
			{
				//根据权值dist[i] 选一个最短路径的顶点。
				int u = 0;
				W minWeit = MAX_W;  //最小权值
				for (size_t i = 0; i < n; i++)
				{
					if (S[i] == false && dist[i] < minWeit)
					{
						u = i;		//找到该点 且该点不在S集合中
						minWeit = dist[i];//记录该点的最短距离（权值）
					}
				}
				S[u] = true; //选出的最小顶点放入S集合中。

				//更新 dist[v]？ 
				// 从上一步确定的最短路径处出发，不仅其相关联的顶点不应在S集合中。
				//而且源点到u 的距离 dist[u] + __matrix[u][v] < 原来源点到v（dist[v]）的距离 。
				for (size_t v = 0; v < n; v++)
				{
					if (S[v] == false && dist[u] + _matrix[u][v] < dist[v] && _matrix[u][v] != MAX_W)
					{
						dist[v] = dist[u] + _matrix[u][v];
						pPath[v] = u;
					}
				}

			}
		}

打印最短路径 和 测试代码

		void PrintShortPath(const V& src, const vector<W>& dist, const vector<int>& pPath)
		{
			size_t srci = GetVertexIndex(src);
			size_t n = _vertexs.size();

			//打印出任意一个顶点的路径。
			for (size_t i = 0; i < n; i++)
			{
				if (i != srci)
				{
					vector<int> ipath;
					int parti = i;
					while (parti != srci)
					{
						ipath.push_back(parti);
						parti = pPath[parti];
					}
					ipath.push_back(srci);
					reverse(ipath.begin(), ipath.end());

					//坐标找顶点
					for (auto& vi : ipath)
					{
						cout << _vertexs[vi] << "->";
					}
					cout << dist[i] << endl;  //i 任意一个顶点距离 源点的权值。
				}
			
			}
		}

---//测试代码
	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);
	}

有负权失效的验证

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

• Dijkstra算法只能用来解决正权图的单源最短路径问题，但有些题目会出现负权图。
• 这时这个算法就不能帮助我们解决问题了，而bellman—ford算法可以解决负权图的单源最短路径问题。
  • 它的优点是可以解决有负权边的单源最短路径问题，而且可以用来判断是否有负权回路。
  • 它也有明显的缺点，它的时间复杂度 O(N*E) (N是点数，E是边数)普遍是要高于Dijkstra算法O(N²)的。
  • 像这里如果我们使用邻接矩阵实现，那么遍历所有边的数量的时间复杂度就是O(N^3)，这里也可以看出来Bellman-Ford就是一种暴力求解更新。

大意：

1. 倘若求s ->j 的最短路径， 则会以 s - >i 为起始边， 把所有的 i ->j 的边都走一遍，确定 s - > j 的最短路径。
2. 只要更新了一条最短路径，可能会影响其他路径。因为其他有的路径就是从你这里过去的，最终导致权值和路径对不上。解决方案是每一条边都更新n轮，就都对了。
3. 两个优化：一、如果这个轮次中没有更新出更短路径，那么后续就不需要走了。因为没有影响任何一条边，给一个像冒泡排序一样的标记位；二、SPFA优化。SPFA算法的全称是：Shortest Path Faster Algorithm，是西南交通大学段凡丁于 1994 年发表的论文中的名字。不过，段凡丁的证明是错误的，且在 Bellman-Ford 算法提出后不久（1957 年）已有队列优化内容，所以国际上不承认 SPFA 算法是段凡丁提出的。
4. 负权回路，如果存在一个环（从某个点出发又回到自己的路径），而且这个环上所有权值之和是负数，那这就是一个负权环，也叫负权回路。负权回路，神仙难救，求不出最短路径。

代码：

		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();

			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 ->j  = srci -> j
						if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
						{
							//看一下每次到目的顶点走的哪条边
							//cout << _vertexs[i] << "->" << _vertexs[j] << ":" << _matrix[i][j] << endl;
							update = true;
							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 ->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.PrintShortPath('s', dist, parentPath);
		}
		else
		{
			cout << "带负权回路" << endl;
		}
		
	}

负权回路的解释：

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

Floyd-Warshall算法是解决任意两点间的最短路径的一种算法。Floyd算法考虑的是一条最短路径的中间节点，即简单路径p={v1,v2,…,vn}上除v1和vn的任意节点。 Dijkstra算法和Bellman-Ford 算法加个 for 循环 也能实现，只不过一个不能有负权，另一个效率低一点。

设 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}取得的一条最短路径。

代码

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

			//更新经过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)
					{
						// 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]存就是x

							vvpPath[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;
		}

代码大意：

1. 理论上 i - > j 共有 n 个点 ，则 i - > j 最多经过 n- 2 个 中间点。但 i j 是两个变换的点， n个点都有可能是其他路径的中间点，所以 k这个中间点还是要循环n次。
2. vector<vector<W>>& vvDist：存储 任意两点之间的最短距离的权值。
3. vector<vector<int>>& vvpPath：存储父路径。起初vvpPath[i][j] = i是因为i，j直接相连，j 的最近上一个父顶点就是 i。
4. k、j 不一定直接相连，而 vvpPath[k][j]中存的就是 k - j 经过的最近的上一个中间顶点。
5. 打印权值矩阵和路径，验证最终结果。
6. 测试代码：

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);

		// 打印任意两点之间的最短路径  矩阵 一行 [i][j]的值 代表这个点 到其他点的最短距离
		for (size_t i = 0; i < strlen(str); ++i)
		{
			g.PrintShortPath(str[i], vvDist[i], vvParentPath[i]);
			cout << endl;
		}
	}

文章来源地址https://www.toymoban.com/news/detail-419521.html

到了这里，关于中级数据结构：图的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！