一、图的基本概念
图是由顶点集合及顶点间的关系组成的一种数据结构：G = (V， E)，其中：V = {x|x属于某个数据对象集}是有穷非空集合；E = {(x,y)|x,y属于V}或者E = {<x, y>|x,y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫做边的集合。
注意:线性表可以是空表，树可以是空树，但图不可以是空图。就是说，图中不能一个顶点也没有，图的顶点集V一定非空，但边集E可以为空，此时图中只有顶点而没有边。
顶点：图中结点称为顶点
边：两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边
无向图：在无向图中，顶点对(x, y)是无序的，顶点对(x,y)称为顶点x和顶点y相关联的一条边，这条边没有特定 方向，(x，y)和(y，x)是同一条边，比如下图G1和G2为无向图。注意：无向边(x, y)等于有向边<x, y>和<y, x>。
有向图：在有向图中，顶点对<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条边。
二、图的存储结构
因为图中既有节点，又有边(节点与节点之间的关系)，因此，在图的存储中，只需要保存节点和边关系即可
2.1 邻接矩阵
因为节点与节点之间的关系就是连通与否，即为0或者1，因此邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系
注意：
1. 无向图的邻接矩阵是对称的，第i行(列)元素之和，就是顶点i的度。有向图的邻接矩阵则不一定是对称的，第i行(列)元素之后就是顶点i 的出(入)度。
2. 如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个顶点不通，则使用无穷大代替。
3. 用邻接矩阵存储图的有点是能够快速知道两个顶点是否连通，缺陷是如果顶点比较多，边比较少时，矩阵中存储了大量的0成为系数矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。
#pragma once
#include<vector>
#include<map>
#include<iostream>
using namespace std;
// 顶点类型，权重类型 有无方向
template<class V,class W ,W W_MAX=INT_MAX,bool Direction=false>
class Graph
{
public:
//构造函数：使用顶点数组进行初始化
Graph(const V* arr,size_t n)
{
//初始化顶点集
_vertex.resize(n);
for (size_t i = 0; i < n; i++)
{
_vertex[i] = arr[i];//存储顶点信息
_Index[arr[i]] = i;//顶点映射的下标
}
//初始化权值矩阵
_matrix.resize(n);
for (size_t i = 0; i < n; i++)
_matrix[i].resize(n,W_MAX);
}
//获取对应下标
size_t GetIndex(const V& src)
{
//一般来说不太可能找不到
auto ret = _Index.find(src);
if (ret != _Index.end())
return ret->second;
else
return -1;
}
//添加边
void AddEdge(const V& src, const V& dst,const W& weight)
{
//换成下标
size_t srci = GetIndex(src);
size_t dsti = GetIndex(dst);
_matrix[srci][dsti] = weight;
if (!Direction)
{
_matrix[dsti][srci] = weight;
}
}
//打印一下关系
void Print()
{
//打印顶点与下标的映射关系
for (size_t i = 0; i < _vertex.size(); i++)
{
cout << "[" << i << "]->" << _vertex[i] << endl;
}
for (size_t i = 0; i < _matrix.size(); i++)
{
for (size_t j = 0; j < _matrix[i].size(); j++)
{
if (_matrix[i][j] == W_MAX)
cout << "* " << " ";
else
cout << _matrix[i][j] << " ";
}
cout << endl;
}
}
private:
vector<V> _vertex;//顶点集
map<V, size_t> _Index;//顶点所对应的下标
vector<vector<W>> _matrix;//权值矩阵（边矩阵）
};
2.1 邻接表
邻接表：使用数组表示顶点的集合，使用链表表示边的关系。
三、图的遍历
3.1 图的广度优先遍历
//广度优先遍历
void BFS(const V& src)
{
//获取下标
size_t srci = GetIndex(src);
//标记数组，标记访问过的元素
vector<bool> visited(_vertex.size(), false);
visited[srci] = true;
//利用队列实现
queue<size_t> q;
q.push(srci);
size_t LevelSize = q.size();
while (!q.empty())
{
//一层一层出
while (LevelSize--)
{
//取队头元素
size_t front = q.front();
//输出当前信息
cout << _vertex[front] << " ";
q.pop();
//把与它相邻的顶点入队列
for (size_t i = 0; i < _vertex.size(); i++)
{
if (_matrix[front][i] != W_MAX&&visited[i]==false)
{
q.push(i);
visited[i] = true;
}
}
}
//获取下一层数据个数
LevelSize = q.size();
cout << endl;
}
cout << endl;
}
3.2 图的深度优先遍历
void _DFS(size_t srci, vector<bool>& visited)
{
cout << _vertex[srci] << " ";
visited[srci] = true;
for (size_t i = 0; i < _vertex.size(); i++)
{
if (_matrix[srci][i] != W_MAX && visited[i] == false)
_DFS(i, visited);
}
}
//DFS
void DFS(const V& src)
{
//获取下标
size_t srci = GetIndex(src);
//标记数组
vector<bool> visited(_vertex.size(), false);
//递归
_DFS(srci, visited);
//解决不连通的情况
for (size_t i = 0; i < _vertex.size(); i++)
{
if (visited[i] == false)
_DFS(i, visited);
}
}
四、最小生成树
连通图中的每一棵生成树，都是原图的一个极大无环子图，即：从其中删去任何一条边，生成树就不在连通；反之，在其中引入任何一条新边，都会形成一条回路。
若连通图由n个顶点组成，则其生成树必含n个顶点和n-1条边。因此构造最小生成树的准则有三条：
1. 只能使用图中的边来构造最小生成树
2. 只能使用恰好n-1条边来连接图中的n个顶点
3. 选用的n-1条边不能构成回路
构造最小生成树的方法：Kruskal算法和Prim算法。这两个算法都采用了逐步求解的贪心策略。
贪心算法：是指在问题求解时，总是做出当前看起来最好的选择。也就是说贪心算法做出的不是整体最优的的选择，而是某种意义上的局部最优解。贪心算法不是对所有的问题都能得到整体最优解。
4.1 Kruskal 算法
任给一个有n个顶点的连通网络N={V,E}，首先构造一个由这n个顶点组成、不含任何边的图G={V,NULL}，其中每个顶点自成一个连通分量，其次不断从E中取出权值最小的一条边(若有多条任取其一)，若该边的两个顶点来自不同的连通分量，则将此边加入到G中。如此重复，直到所有顶点在同一个连通分量上为止。
核心：每次迭代时，选出一条具有最小权值，且两端点不在同一连通分量上的边，加入生成树。
下图摘自《算法导论》
//边
struct Edge
{
size_t _srci;
size_t _dsti;
W _weight;
Edge(size_t srci, size_t dsti, W& weight):_srci(srci),_dsti(dsti),_weight(weight){}
bool operator>(const Edge& e) const
{
return _weight > e._weight;
}
};
//最小生成树：Kruskal算法
W Kruskal(Graph& minTree)
{
//初始化最小生成树
minTree._vertex = _vertex;
minTree._Index = _Index;
minTree._matrix.resize(_vertex.size());
for (size_t i = 0; i < _vertex.size(); i++)
minTree._matrix[i].resize(_vertex.size(),W_MAX);
//每次都选取权值最小的边
priority_queue<Edge, vector<Edge>, greater<Edge>> pqmin;
//建立小根堆
size_t size = _vertex.size();
for (size_t i = 0; i < size; i++)
{
for (size_t j = i; j < size; j++)
{
if (_matrix[i][j] != W_MAX)
pqmin.push(Edge(i, j, _matrix[i][j]));
}
}
size_t n = 0;
W total = W(); //总的权重
//使用并查集判断两个顶点是否在一个集合
UnionFindSet ufs(_vertex.size());
//找到n-1条边建立minTree
while (!pqmin.empty())
{
//取最小边建立联系
Edge min = pqmin.top();
pqmin.pop();
//不在同一个集合可以建边
if(!ufs.IsSameSet(min._srci,min._dsti))
{
cout << _vertex[min._srci] << "->" << _vertex[min._dsti] <<":"<<min._weight << endl;
minTree._AddEdge(min._dsti, min._dsti,min._weight);
ufs.UnionSet(min._srci, min._dsti);
n++;
total += min._weight;
}
}
//建立了n-1条边就返回权重
if (n == _vertex.size() - 1)
return total;
else
return W();
}
4.2 Prim 算法
//边
struct Edge
{
size_t _srci;
size_t _dsti;
W _weight;
Edge(size_t srci, size_t dsti, W& weight):_srci(srci),_dsti(dsti),_weight(weight){}
bool operator>(const Edge& e) const
{
return _weight > e._weight;
}
};
//最小生成树：Prim算法
W Prim(Graph& minTree,const V&src)
{
//获取下标
size_t srci = GetIndex(src);
//初始化最小生成树
minTree._vertex = _vertex;
minTree._Index = _Index;
minTree._matrix.resize(_vertex.size());
for (size_t i = 0; i < _vertex.size(); i++)
minTree._matrix[i].resize(_vertex.size(), W_MAX);
//判断是否在一个集合
UnionFindSet ufs(_vertex.size());
//建小堆
priority_queue<Edge, vector<Edge>, greater<Edge>> minque;
//把与srci相邻的顶点所构成的边都添加到小堆里
for (size_t i = 0; i < _vertex.size(); i++)
{
if (_matrix[srci][i] != W_MAX)
minque.push(Edge(srci, i, _matrix[srci][i]));
}
int n = 0;
W total = W();
//循环选边
while (!minque.empty())
{
//取出当前最小的边
Edge min = minque.top();
minque.pop();
//判断是否构成环
if (!ufs.IsSameSet(min._srci, min._dsti))
{
cout << _vertex[min._srci] << "->" << _vertex[min._dsti] << ":" << min._weight << endl;
minTree._AddEdge(min._srci, min._dsti, _matrix[min._srci][min._dsti]);
ufs.UnionSet(min._srci, min._dsti);
n++;
total += _matrix[min._srci][min._dsti];
//相邻的边进入小堆
for (size_t i = 0; i < _vertex.size(); i++)
{
if(_matrix[min._dsti][i] != W_MAX)
minque.push(Edge(min._dsti, i, _matrix[min._dsti][i]));
}
}
}
//建立了n-1条边就返回权重
if (n == _vertex.size() - 1)
return total;
else
return W();
}
五、最短路径
最短路径问题：从在带权有向图G中的某一顶点出发，找出一条通往另一顶点的最短路径，最短也就是沿路径各边的权值总和达到最小。
5.1单源最短路径 – Dijkstra 算法
//最短路径算法：Dijkstra算法
//源点 权值数组 父路径数组
void Dijkstra(const V& src,vector<W>& dist,vector<int>& parentPath)
{
//获取下标
size_t srci = GetIndex(src);
//顶点个数
size_t n = _vertex.size();
//初始化距离数组，父路径数组
dist.resize(n, W_MAX);
parentPath.resize(n, -1);
//对源点记录
dist[srci] = 0;
parentPath[srci] = srci;
//标记数组
vector<bool> visited(n, false);
//更新剩余点位
for(size_t j=0;j<n;j++)
{
size_t cur = 0;
//找距离srci最短的顶点,更新最短路径
W min = W_MAX;//最短距离
for (size_t i = 0; i < n; i++)
{
if (visited[i]==false&&dist[i]< min)
{
min = dist[i];
cur = i;
}
}
visited[cur] = true;//标记
//松弛操作
for (size_t i = 0; i < n; i++)
{
if (visited[j] == false && _matrix[cur][i] != W_MAX && dist[cur] + _matrix[cur][i] < dist[i])
{
dist[i] = dist[cur] + _matrix[cur][i];
parentPath[i] = cur;
}
}
}
}