目录
正文
1. 图论基础
1.1 图的定义
图（Graph）是由顶点（Vertex）的有穷非空集合和顶点之间边（Edge）的集合组成，通常表示为 G = ( V , E ) G=(V, E) G=(V,E)，其中 V V V 是顶点集合， E E E 是边集合。
1.2 图的分类
- 无向图：边没有方向，若顶点 v 1 v_1 v1 和 v 2 v_2 v2 之间有边相连，则 ( v 1 , v 2 ) (v_1, v_2) (v1,v2) 和 ( v 2 , v 1 ) (v_2, v_1) (v2,v1) 表示同一条边。
- 有向图：边是有方向的，从顶点 v 1 v_1 v1 指向 v 2 v_2 v2 的边表示为 ⟨ v 1 , v 2 ⟩ \langle v_1, v_2\rangle ⟨v1,v2⟩，和 ⟨ v 2 , v 1 ⟩ \langle v_2, v_1\rangle ⟨v2,v1⟩ 是不同的两条边。
2. 图的存储表示
2.1 邻接矩阵
邻接矩阵（Adjacency Matrix）是表示图的一种常用方式。对于具有 n n n 个顶点的图，使用一个 n × n n \times n n×n 的二维数组来存储图中顶点之间的连接关系。
- 无向图的邻接矩阵：若顶点 i i i 和顶点 j j j 之间有边相连，则矩阵中 a i j = a j i = 1 a_{ij}=a_{ji}=1 aij=aji=1（通常用 1 表示有边，0 表示无边）；若没有边相连，则 a i j = a j i = 0 a_{ij}=a_{ji}=0 aij=aji=0。
- 有向图的邻接矩阵：若存在从顶点 i i i 指向顶点 j j j 的边，则 a i j = 1 a_{ij}=1 aij=1，否则 a i j = 0 a_{ij}=0 aij=0。
以下是C++ 代码示例，展示如何用邻接矩阵表示无向图：
#include <iostream>
#include <vector>
using namespace std;
class Graph {
private:
int numVertices;
vector<vector<int>> adjMatrix;
public:
Graph(int vertices) {
numVertices = vertices;
adjMatrix.resize(numVertices, vector<int>(numVertices, 0));
}
void addEdge(int src, int dest) {
// 无向图，对称赋值
adjMatrix[src][dest] = 1;
adjMatrix[dest][src] = 1;
}
void printGraph() {
for (int i = 0; i < numVertices; i++) {
for (int j = 0; j < numVertices; j++) {
cout << adjMatrix[i][j] << " ";
}
cout << endl;
}
}
};
int main() {
Graph g(5);
g.addEdge(0, 1);
g.addEdge(0, 4);
g.addEdge(1, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(2, 3);
g.addEdge(3, 4);
g.printGraph();
return 0;
}
2.2 邻接表
邻接表（Adjacency List）也是一种图的存储结构，它使用一个数组（或链表）来存储每个顶点，每个顶点对应一个链表，链表中存储的是与该顶点相邻的顶点。
3. 图的遍历
3.1 深度优先搜索（DFS）
深度优先搜索是一种图的遍历算法，它从图的某个顶点开始，沿着一条路径尽可能深地访问顶点，直到无法继续或者达到目标顶点，然后回溯到上一层未访问的顶点，继续进行搜索。
以下是基于前面邻接矩阵表示的图进行深度优先搜索的C++ 代码示例：
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
class Graph {
private:
int numVertices;
vector<vector<int>> adjMatrix;
public:
Graph(int vertices) {
numVertices = vertices;
adjMatrix.resize(numVertices, vector<int>(numVertices, 0));
}
void addEdge(int src, int dest) {
adjMatrix[src][dest] = 1;
adjMatrix[dest][src] = 1;
}
void DFS(int startVertex) {
vector<bool> visited(numVertices, false);
stack<int> s;
s.push(startVertex);
visited[startVertex] = true;
while (!s.empty()) {
int currentVertex = s.top();
s.pop();
cout << currentVertex << " ";
for (int i = 0; i < numVertices; i++) {
if (adjMatrix[currentVertex][i] == 1 &&!visited[i]) {
s.push(i);
visited[i] = true;
}
}
}
}
};
int main() {
Graph g(5);
g.addEdge(0, 1);
g.addEdge(0, 4);
g.addEdge(1, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(2, 3);
g.addEdge(3, 4);
g.DFS(0);
return 0;
}
3.2 广度优先搜索（BFS）
广度优先搜索是从图的某个顶点开始，先访问该顶点的所有邻接顶点，然后再依次访问这些邻接顶点的邻接顶点，以此类推，按照层次依次访问图中的所有顶点。
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
// 定义图类
class Graph {
private:
int numVertices;
vector<vector<int>> adjMatrix;
public:
Graph(int vertices) {
numVertices = vertices;
adjMatrix.resize(numVertices, vector<int>(numVertices, 0));
}
// 添加边的函数
void addEdge(int src, int dest) {
adjMatrix[src][dest] = 1;
adjMatrix[dest][src] = 1;
}
// 广度优先搜索函数
void BFS(int startVertex) {
vector<bool> visited(numVertices, false);
queue<int> q;
visited[startVertex] = true;
q.push(startVertex);
while (!q.empty()) {
int currentVertex = q.front();
q.pop();
cout << currentVertex << " ";
// 遍历当前顶点的所有邻接顶点
for (int i = 0; i < numVertices; i++) {
if (adjMatrix[currentVertex][i] == 1 &&!visited[i]) {
visited[i] = true;
q.push(i);
}
}
}
}
};
int main() {
Graph g(6);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 3);
g.addEdge(1, 4);
g.addEdge(2, 4);
g.addEdge(3, 5);
g.addEdge(4, 5);
g.BFS(0);
return 0;
}
4. 最小生成树
4.1 普里姆算法（Prim’s Algorithm）
普里姆算法用于在加权连通无向图中寻找最小生成树。它从任意一个顶点开始，每次选择与当前已加入最小生成树的顶点集合距离最近（边权值最小）的顶点加入集合，直到所有顶点都被加入。
以下是使用C++实现普里姆算法的代码示例：
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
// 表示图中顶点的数量
const int V = 5;
class Graph {
public:
vector<vector<int>> adjMatrix;
Graph() {
adjMatrix.resize(V, vector<int>(V, INT_MAX));
for (int i = 0; i < V; i++) {
adjMatrix[i][i] = 0;
}
}
void addEdge(int u, int v, int weight) {
adjMatrix[u][v] = weight;
adjMatrix[v][u] = weight;
}
int primMST() {
vector<int> key(V, INT_MAX);
vector<bool> mstSet(V, false);
key[0] = 0;
int result = 0;
for (int count = 0; count < V - 1; count++) {
int minKey = INT_MAX, minIndex;
// 找到未加入MST中具有最小键值的顶点
for (int v = 0; v < V; v++) {
if (!mstSet[v] && key[v] < minKey) {
minKey = key[v];
minIndex = v;
}
}
mstSet[minIndex] = true;
result += minKey;
// 更新与刚加入顶点相邻顶点的键值
for (int v = 0; v < V; v++) {
if (!mstSet[v] && adjMatrix[minIndex][v] < key[v]) {
key[v] = adjMatrix[minIndex][v];
}
}
}
return result;
}
};
int main() {
Graph g;
g.addEdge(0, 1, 2);
g.addEdge(0, 3, 6);
g.addEdge(1, 2, 3);
g.addEdge(1, 3, 8);
g.addEdge(1, 4, 5);
g.addEdge(2, 4, 7);
g.addEdge(3, 4, 9);
cout << "最小生成树的权重为: " << g.primMST() << endl;
return 0;
}
4.2 克鲁斯卡尔算法（Kruskal’s Algorithm）
克鲁斯卡尔算法是另一种求最小生成树的贪心算法，它按照边的权值从小到大依次选择边，如果加入某条边不会形成环，就将其加入到最小生成树中，直到生成树包含了所有顶点。
下面是C++实现克鲁斯卡尔算法的代码示例，这里我们借助并查集（Union-Find）数据结构来判断是否形成环：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
// 边的结构体，用于存储边的两个端点和权值
struct Edge {
int src, dest, weight;
};
// 并查集数据结构相关函数
class UnionFind {
private:
vector<int> parent;
public:
UnionFind(int n) {
parent.resize(n);
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
int find(int x) {
if (parent[x]!= x) {
parent[x] = find(parent[x]);
}
return parent[x];
}
void unionSet(int x, int y) {
int rootX = find(x);
int rootY = find(y);
if (rootX!= rootY) {
parent[rootY] = rootX;
}
}
};
// 比较函数，用于对边按照权值从小到大排序
bool compareEdges(const Edge& a, const Edge& b) {
return a.weight < b.weight;
}
// 克鲁斯卡尔算法实现
int kruskalMST(vector<Edge>& edges, int V) {
sort(edges.begin(), edges.end(), compareEdges);
UnionFind uf(V);
int mstWeight = 0;
int edgeCount = 0;
for (Edge e : edges) {
int set_u = uf.find(e.src);
int set_v = uf.find(e.dest);
if (set_u!= set_v) {
mstWeight += e.weight;
uf.unionSet(set_u, set_v);
edgeCount++;
if (edgeCount == V - 1) {
break;
}
}
}
return mstWeight;
}
int main() {
int V = 4;
vector<Edge> edges = {
{0, 1, 10},
{0, 2, 6},
{0, 3, 5},
{1, 3, 15},
{2, 3, 4}
};
cout << "最小生成树的权重为: " << kruskalMST(edges, V) << endl;
return 0;
}
5. 最短路径算法
5.1 迪杰斯特拉算法（Dijkstra’s Algorithm）
迪杰斯特拉算法用于解决单源最短路径问题，即给定一个起点，求该起点到图中其他所有顶点的最短路径长度。它也是基于贪心策略，每次选择距离起点最近的未确定最短路径的顶点进行松弛操作（更新到其他顶点的距离）。
以下是C++代码示例：
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
// 表示图中顶点数量
const int V = 6;
class Graph {
public:
vector<vector<int>> adjMatrix;
Graph() {
adjMatrix.resize(V, vector<int>(V, INT_MAX));
for (int i = 0; i < V; i++) {
adjMatrix[i][i] = 0;
}
}
void addEdge(int u, int v, int weight) {
adjMatrix[u][v] = weight;
}
void dijkstra(int src) {
vector<int> dist(V, INT_MAX);
vector<bool> sptSet(V, false);
dist[src] = 0;
for (int count = 0; count < V - 1; count++) {
int minDist = INT_MAX, minIndex;
// 找到未在最短路径树中的具有最小距离的顶点
for (int v = 0; v < V; v++) {
if (!sptSet[v] && dist[v] < minDist) {
minDist = dist[v];
minIndex = v;
}
}
sptSet[minIndex] = true;
// 对与刚确定的顶点相邻的顶点进行松弛操作
for (int v = 0; v < V; v++) {
if (!sptSet[v] && adjMatrix[minIndex][v]!= INT_MAX &&
dist[minIndex] + adjMatrix[minIndex][v] < dist[v]) {
dist[v] = dist[minIndex] + adjMatrix[minIndex][v];
}
}
}
cout << "从顶点 " << src << " 到各顶点的最短路径长度如下: " << endl;
for (int i = 0; i < V; i++) {
cout << "到顶点 " << i << " 的最短路径长度: " << dist[i] << endl;
}
}
};
int main() {
Graph g;
g.addEdge(0, 1, 4);
g.addEdge(0, 2, 2);
g.addEdge(1, 2, 5);
g.addEdge(1, 3, 10);
g.addEdge(2, 3, 8);
g.addEdge(2, 4, 15);
g.addEdge(3, 4, 6);
g.addEdge(3, 5, 20);
g.addEdge(4, 5, 1);
g.dijkstra(0);
return 0;
}
5.2 弗洛伊德算法（Floyd’s Algorithm）
弗洛伊德算法可以解决全源最短路径问题，即求图中任意两个顶点之间的最短路径长度。它通过动态规划的思想，不断更新中间顶点来优化两点之间的最短路径。
以下是C++实现弗洛伊德算法的代码示例：
#include <iostream>
#include <vector>
using namespace std;
const int V = 4;
void floydWarshall(vector<vector<int>>& graph) {
vector<vector<int>> dist = graph;
for (int k = 0; k < V; k++) {
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (dist[i][k]!= INT_MAX && dist[k][j]!= INT_MAX &&
dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
cout << "各顶点之间的最短路径长度如下: " << endl;
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (dist[i][j] == INT_MAX) {
cout << "INF ";
} else {
cout << dist[i][j] << " ";
}
}
cout << endl;
}
}
int main() {
vector<vector<int>> graph = {
{0, 5, INT_MAX, 10},
{INT_MAX, 0, 3, INT_MAX},
{INT_MAX, INT_MAX, 0, 1},
{INT_MAX, INT_MAX, INT_MAX, 0}
};
floydWarshall(graph);
return 0;
}
结语
感谢您的阅读！期待您的一键三连！欢迎指正！
扫一扫
2143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
