图（Graph）详解 - 数据结构

图的基本概念

图（Graph）是由两个集合构成，一个是非空但有限的顶点集合V，另一个是描述顶点之间关系 ----- 边的集合E（可以是∅）。图可以表示为 G=（V,E）。每条边是一顶点对（v,w）且 v,w∈V。通常用 |V| 表示顶点的数量，用 |E| 表示边的数量。

🚀图是由顶点集合及顶点间的关系组成的一种数据结构：G = （V，E），其中：顶点集合 V = {x|x 属于某个数据对象集} 是有穷非空集合；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>是两条不同的边，比如下图 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 条边。

图的存储结构

图是一种结构复杂的数据结构，主要表现在逻辑上任意顶点之间都可以存在特定关系。从图的定义可知，一个图的信息包括两部分，即图中顶点的信息以及描述顶点之间的关系 ---- 边或者弧的信息。因此无论采用什么方法建立图的存储结构，都要完整、准确地反映这两个面的信息。下面介绍两种常用的图的存储结构。

邻接矩阵

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

• 无向图的邻接矩阵是对称的，第 i 行(列)元素之和就是顶点 i 的度。有向图的邻接矩阵不一定是对称的，第 i 行(列)元素之后就是顶点 i 的出(入)度。
• 若边带有权值，并且两个节点之间是联通的，上图中的关系就用权值代替，若两个顶点不连通，则使用无穷大替代。
  
• 邻接矩阵存储图的优点是能够快速知道图中两个顶点是否联通，缺点是顶点很多且边比较少时，比较浪费空间，并且两个节点之间的路径不好求。若要确定图中有多少条边，需要遍历一遍邻接矩阵，空间复杂度为 O(N^2) 。这是用邻接矩阵来存储图的局限性。

邻接矩阵的实现

邻接矩阵表示法的结构和类型声明

邻接矩阵的实现结构中需要用 vector 存储各个顶点，以及用 map 存储各个顶点对应的下标，方便查找。邻接矩阵是一个二维数组，我们使用 vector 容器嵌套的方式实现。结构中模板参数的含义：V - 顶点，W - 权值，MAX_W - 最大值(默认参数给整形的最大值)，Direction - 表示图是否有方向。

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

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

构造函数

构造函数需要为存储顶点的数组开好对应的空间并将顶点存储进去。map 中建立好顶点与下标之间的映射关系，将邻接矩阵初始化。

Graph() = default; 

Graph(const V* a, size_t n)
{
	// 为存储顶点的数组开好空间
	_vertexs.reserve(n);
	for (size_t i = 0;i < n;++i)
	{
		// 将传入数组的值存储到vector中
		_vertexs.push_back(a[i]);
		// 让数组中的每一个数据映射一个下标
		_indexMap[a[i]] = i;
	}

	// 为邻接矩阵开好空间并初始化，MAX_W作为不存在边的标识值
	_matrix.resize(n);
	for (size_t i = 0;i < _martix.size();++i)
	{
		_matrix[i].resize(n, MAX_W);
	}
	
	// 将矩阵的对角线初始化为0
	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] = 0;
		}
	}
}

顶点或者顶点下标构造邻接矩阵

// 返回顶点下标
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);

	_AddEdge(srci, dsti, w);
}

// 通过顶点下标构造邻接矩阵
_AddEdge(size_t srci, size_t dsti, const W& w)
{
	_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)
	{
		printf("%5d", 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)
				printf("%5c", '*');
			else
				printf("%5d", _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;
		}
	}
}

邻接表

邻接表(Adjacency Lists)是图的一种顺序存储与链式存储结合的存储方法。邻接表表示法就是对于图 G 中的每个顶点 vi，将所有邻接与 vi 的顶点 vj 链成一个单链表，这个单链表称为顶点 vi 的邻接表，然后将所有点的邻接表表头放入一个数组中，就构成了图的邻接表。

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

无向图邻接表存储：

注意：

• 无向图中同一条边在邻接表中出现了两次。若想知道顶点 vi 的度，只需要知道顶点 vi 边链表集合中结点的数目即可。
• 若是有向图存储在邻接表中，可以存一个出边表和一个入边表，但是实际中我们一般只需要存储出边表即可。
• 有向图中每条边在邻接表中只出现一次，与顶点 vi 对应的邻接表所含结点的个数，就是该顶点的出度，也称为出度表，要得到顶点 vi 的入度，需要检测其它所有顶点对应的边链表，检测有多少边顶点的 dst 取值是 i 。
• 若邻接表中需要存储权值，我们只需要在存储结点中增加一个存储权值的变量即可。

邻接表实现

namespace link_table
{
	template<class W>
	struct Edge
	{
		size_t _dsti;       // 目标点下标
		W _w;            // 权值
		Edge<W>* _next;

		Edge(size_t dsti,const W& w)
			:_dsti(dsti)
			,_w(w)
			,_next(nullptr)
		{}
	};

	template<class V, class W, bool Dircetion = 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
			{
				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);

			// 采用链表头插的方式将新节点插入链表
			Edge* eg = new Edge(dsti, w);
			eg->_next = _tables[srci];
			_tables[srci] = eg;

			// 无向图处理
			if (Dircetion == 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, size_t> _indexMap;   // 顶点映射的下标
		vector<Edge*> _tables;      // 邻接表
	};
}

图的遍历

给定一个图 G 和其中的任意一个顶点 v0，从 v0 出发，沿着图中各边访问图中的所有顶点，且每个顶点仅被遍历一次。图的遍历操作额数的遍历操作相似。图的遍历是图的一种基本操作，图的许多其它操作都是建立在遍历的基础之上。我们可以使用 O(V+E)DFS(深度优先搜索)或 BFS(广度优先搜索)算法来遍历该图并探索图的特征/属性。每种算法都有自己的特点、特征和副作用。

图的广度优先搜索（BFS）

广度优先搜索（Breadth First Search）简称 BFS，是遍历图存储结构的一种算法，既适用于无向图，也适用于有向图。

首先通过一个样例，演示一下广度优先搜索算法是如何实现图的遍历的：

思路：

• 使用一个数组来标记各个顶点的状态，数组中有 false 和 true 两种状态，false 表示该顶点还未入队列，true 表示该顶点已经进入队列了。每当顶点入队列时，就将该顶点标记为 true，防止重复访问。
• 一个顶点出队列时，就将该顶点的未入队列的邻接顶点进入队列，并将进入队列的顶点的状态置为 true。
• 队列为空时，代表图已经访问完毕。
  

BFS代码： 下列代码遍历时采用一层一层遍历的方式

void BFS(const V& src)
{
	// 获取开始顶点下标
	size_t srci = GetVertexIndex(src);
	size_t n = _vertexs.size();

	// 队列和标记数组，使用false进行初始化
	queue<int> q;
	vector<bool> visited(n, false);

	// 首先将开始顶点入队列，并将其状态置为true
	q.push(srci);
	visited[srci] = true;
	int levelSize = 1;

	int count = 0;
	// 队列为空，则遍历结束
	while (!q.empty())
	{
		cout << "第" << count++ << "层: ";
		for (size_t k = 0;k < levelSize;++k)
		{
			// 访问队头元素并将其从队列中删除
			int front = q.front();
			q.pop();
			cout << "[" << front << "]" << _vertexs[front] << " ";

			// 将该顶点未访问过的邻接顶点入队列，并标记其状态
			for (size_t i = 0;i < n;++i)
			{
				if (_matrix[front][i] != MAX_W && visited[i] == false)
				{
					q.push(i);
					visited[i] = true;
				}
			}
		}
		levelSize = q.size();
		cout << endl;
	}
}

图的深度优先搜索（DFS）

深度优先搜索（Depth First Search）简称 DFS，是遍历图存储结构的一种算法，既适用于无向图，也适用于有向图。

首先通过一个样例，演示一下深度优先搜索算法是如何实现图的遍历的：

思路：

• 使用一个状态标记数组，数组中有 false 和 true 两种状态，false 表示该顶点未访问过，true 表示该顶点已经访问过了，没访问一个顶点，就将状态数组中其下标对应的位置标记为 true。
• 使用递归的方式进行深度遍历。

DFS代码：

void _DFS(size_t srci, vector<bool>& visited)
{
	// 访问此顶点元素，并将其状态置为true
	cout << "[" << srci << "]" << _vertexs[srci] << "  ";
	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);
}

图的遍历有许多应用，比如求联通分量、欧拉回路、生成树、DAG的判定、DAG的根、桥边、关节点等的计算都可以通过遍历来进行。

最小生成树

一个连通无向有权图 G 的生成树 Spanning Tree(ST)是 G 的子图，同时也是一个连接 G 中所有节点的树。一个图 G 可以有很多的生成树，而每一个都有不同的总权重（生成树中所有边的权重之和）。图 G 的最小生成树 Min(imum) Spanning Tree(MST)是在所有的生成树中，有着最小总权重的生成树。

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

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

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

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

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

最小生成树在实际中的应用：政府想要用 n-1 条边将 n 个地区连接起来，路的造价取决于地形、距离等。你想要最小的造价，应该怎样建这些路呢？（这就是一个最小生成树问题）

Kruskal算法

一个 O(E log V) 的贪心最小生成树算法。它扩展一个最小生成树的森林，直到将他们组合成一个最小生成树。Kruskal 算法需要一个较好的排序算法来对图中的边以权值的非递减排序（通常存储在边列表内）和并查集（UFDS）来判断/预防成环。

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

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

下图将使用一个案例来演示 Kruskal 算法：

---

问题：如何避免选边过程中形成环？

解决方案：在选出一条边之后，将边两端的顶点加入并查集中，当我们再次选出边之后，我们需要使用并查集判断边的两个顶点是否在同一个并查集中，若在则不处理，不在则添加到最小生成树中。

---

Kruskal算法实现的核心有以下三点：

1. 选择一条权值最小的边。可以采用优先级队列（最小堆）的数据结构，然后把所有的边都加入进去。建初始堆的时间复杂度是O(E)，删除堆顶元素后重组一个堆的时间复杂度为O(logE)，所以总的时间复杂度还是O(ElogE)。
2. 判定一条边的两端是否属于同一颗树，这可以由并查集来辅助完成。用 InSameSet(u,v) 来测试以节点 u 和 v 为端点的边 e 是否会导致环（相同的连接分支 – 由另一条从 u 到 v 的路，所以添加边（u,v）会导致成环）。如果 IsSameSet(u,v) 为 false，贪心的选择下一个最小的合格边 e 并调用 UnionSet(u,v) 来预防可能的与此边相关的环。
3. 如果 IsSameSet(u,v) 为 false，贪心的选择下一个最小的合格边 e 并调用 UnionSet(u,v) 来预防可能的与此边相关的环。

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& e)const
	{
		return _w > e._w;
	}
};

W Kruskal(Self& minTree)
{
	int 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.InSameSet(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;
		}
	}

	// 若选出的边数为n-1，则返回总权重
	if (size == n - 1)
		return totalW;
	// 没有选出最小生成树，返回默认值
	else
		return W();
}

Prim算法

普里姆(Prim)算法，和克鲁斯卡尔算法类似。一个 O(E log V) 的贪心最小生成树算法。它从一个起始的源节点开始逐渐扩张到整个图，从而生成一个最小生成树。Prim 算法需要使用优先级队列以权重的非递减次序来动态排序当前的边，用邻接矩阵来找到一个节点的邻接顶点，和一个布尔数组来帮助判断环。

下图将使用一个案例来演示 Prim 算法：

Prim算法实现步骤：

1. 获取传入顶点的下标，然后初始化最小生成树。
2. 定义两个布尔数组（S 和 D），S 数组用来标记已经被选择过的顶点，D 数组用来标记图中未被选择的顶点，并将两个数组中源点的存在状态更新。
3. 用一个优先级队列将源点连接出去的边添加进去。
4. 以队列是否为空来作为循环的条件，出队列顶部的数据，判断选出的边是否构成环。
5. 当选出的边符合条件之后，就将其添加到最小生成树中，然后更新两个数组中该边目标顶点的存在状态。将该边目标顶点连接出去的边添加到优先级队列中（选出的目标顶点需在D数组中存在，否则不能添加到优先级队列中）。

Prim算法实现代码： 具体实现细节参考代码

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 Prim(Self& minTree, const V& src)
{
	// 获取源点下标
	size_t srci = GetVertexIndex(src);
	int 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);
	}

	// 定义一个优先级队列来排序各边，从S->D集合中连接的边里面选出最小的边
	priority_queue<Edge, vector<Edge>, greater<Edge>> minque;

	// S为源数组 - 用来标记已经被选择的顶点
	// D为目标数组 - 用来标识没有被选择的顶点
	vector<bool> S(n, false);
	vector<bool> D(n, true);
	S[srci] = true;
	D[srci] = false;

	// 将图中以srci为源点的各条边加入优先级队列中
	for (int i = 0;i < n;++i)
	{
		if (_matrix[srci][i] != MAX_W && i != srci)
		{
			minque.push(Edge(srci, i, _matrix[srci][i]));
		}
	}

	size_t size = 0; // 用来记录选择的边数目
	W totalW = W();  // 记录选出的边的总权重
	while (!minque.empty())
	{
		Edge min = minque.top();
		minque.pop();

		// 若选出的最小边的目标点也在集合S中，则构成环
		if (S[min._dsti]){}
		else
		{
			// 将选出的边添加到最小生成树中
			minTree._AddEdge(min._srci, min._dsti, min._w);

			// 更新该边的两端顶点在两个数组中的状态
			S[min._dsti] = true;
			D[min._dsti] = false;
			// 更新两个变量记录的数据
			++size;
			totalW += min._w;

			// 选出的边达到要求，则跳出循环
			if (n - 1 == size)
				break;

			// 以选出的边的目标顶点为源点选出它的邻接顶点入队列，且邻接顶点在D数组中为true状态
			for (size_t i = 0;i < n;++i)
			{
				if (_matrix[min._dsti][i] != MAX_W && D[i])
				{
					minque.push(Edge(min._dsti, i, _matrix[min._dsti][i]));
				}
			}
		}
	}

	if (size == n - 1)
		return totalW;
	else
		return W();
}

最短路径

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

最短路径问题是图论中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。算法具体的形式包括：确定起点的最短路径问题 - 也叫单源最短路径问题，即已知起始结点，求最短路径的问题。在边权非负时适合使用 Dijkstra 算法，若边权为负时则适合使用Bellman - ford 算法或者 SPFA 算法。

单源最短路径 - 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 算法存在的问题是不支持图中带负权路径，若带有负权路径，则可能会找不到一些路径的最短路径。

下图将使用一个案例来演示 Dijkstra 算法：

接下来用《算法导论》上的案例来分析一下实现要点及步骤：

1. 用数组 vector<W> dist 来记录 srci 到其它顶点的最短路径权值，数组 vector<int> pPath 来记录 srci 到其它顶点最短路径父顶点。然后将两个数组初始化，将 dist 中的 n 个数据初始化为最大值（除源点 srci 对应的位置，srci 的位置初始化为 0）；将 pPath 中的 n 个数据初始化为 -1（除源点 srci 对应的位置，srci 的位置初始化为 0）。
2. 用一个布尔数组 S 来记录已经确定最短路径的顶点集合。
3. 选出未确定最短路径的顶点中权值最小的那一个顶点，松弛更新该节点连接出去且未确定最短路径的邻接顶点的权值。
4. 循环更新 n 次。更新过程中一直记录路径数组。
   

Dijkstra算法实现代码：

// dist用来存储当前顶点的权值，pPth用来记录更新路径
void Dijkstra(const V& src, vector<W>& dist, vector<int>& pPath)
{
	size_t srci = GetVertexIndex(src);
	size_t n = _vertexs.size();
	
	// vector<W> dist,记录srci - 其它顶点最短路径权值数组
	dist.resize(n, MAX_W);
	// vector<int> pPath,记录srci - 其它顶点最短路径父顶点数组
	pPath.resize(n, -1);

	dist[srci] = 0;
	pPath[srci] = srci;

	// 标记已经确定最短路径的顶点集合
	vector<bool> S(n, false);

	// 循环更新n次
	for (size_t k = 0;k < n;++k)
	{
		// 选最短路径顶点且不在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 (S[v] == false && _matrix[u][v] != MAX_W && dist[u] + _matrix[u][v] < dist[v])
			{
				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)
		{
			// 找出i顶点的路径
			vector<int> path;
			size_t parenti = i;
			while (parenti != srci)
			{
				path.push_back(parenti);
				parenti = pPath[parenti];
			}
			path.push_back(srci);
			reverse(path.begin(), path.end());

			for (auto index : path)
			{
				cout << _vertexs[index] << "->";
			}
			cout << dist[i] << endl;
		}
	}
}

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

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

下面将使用两个案例用 Bellman - Ford 算法来分别演示 带负权的图查找最短路径 和 带有负权回路的图无法查找出最短路径 的过程：

带负权路径的图：

带负权回路的图

Bellman - Ford 算法采用动态规划（Dynamic Programming）进行设计。Bellman - Ford 算法描述：

1. 创建源顶点 srci 到图中所有顶点的距离集合 vector<W> dist ，为图中的所有顶点初始化一个距离值，初始化为 ∞ ，源顶点的距离初始化为顶点类型的默认值 W()。创建其它顶点最短路径父顶点数组 vector<int> pPath ，将数组中的每个位置初始化为 -1。
2. 更新方法与 Dijkstra 算法类似，因为可能存在父路径，所以 n 次暴力更新最短路径。
3. n 次暴力更新效率上比较低，因此我们加一个标记变量 update 来标记每一轮中是否更新出更短的路径，若在循环时不再更新出更短的路径，则直接跳出循环。
4. 遍历都结束后，再次进行一次遍历，若还能更新出更短的路径，则说明图中存在负权回路。

思路上与 Dijkstra 算法最大的不同是每次都是从源点 srci 重新出发进行松弛更新操作，而 Dijkstra 算法则是从源点出发逐渐向外扩逐处理邻接顶点，不会重复处理节点。因此，Dijkstra 算法的效率相对更高。但是 Dijkstra 算法无法处理带负权的最短路径问题。而 Bellman - Ford 算法虽能处理负权路径，但是效率低，因此有人就对 Bellman - Ford 算法进行了优化。这里就不说了，需要了解的可以参考这篇文章：最短路径|优化Bellman-Ford（SPFA）

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->j
				if (_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)
		{
			if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
			{
				// 带有负权回路，无法解决，返回false
				return false;
			}
		}
	}

	return true;
} 

多源最短路径 - 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）取得的一条最短路径。p2 是从 k 到 j 且中间节点属于（1,2,…,k）取得的一条最短路径。

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

Floyd 算法适用于 APSP（All Pairs Shortest Paths，多源最短路径），是一种动态规划算法，稠密图效果最佳，边权可正可负。此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次 Dijkstra 算法，也要高于执行|V|次 SPFA 算法。

优点：容易理解，可以算出任意两个顶点之间得最短距离，代码编写简单。

缺点：时间复杂度较高，不适合计算大量数据。

Floyd-Warshall算法代码实现：

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

	// 最短路径的更新 i->{其它顶点}->j
	// 依次用顶点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)
					printf("%3c", '*');
				else
					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)
			{
				printf("%3d", vvpPath[i][j]);
			}
			cout << endl;
		}

		cout << "===========================" << endl;
	}
}

文中部分图以及代码思想参考书籍《算法导论》。