数据结构之图论算法（邻接矩阵）

最新推荐文章于 2023-04-11 10:47:46 发布
最新推荐文章于 2023-04-11 10:47:46 发布
阅读量786 收藏
点赞数 1
分类专栏： 笔记 文章标签： 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55850954/article/details/121501132
版权
本文详细介绍了图论算法的实现，包括邻接矩阵创建图、拓扑排序、无权最短路径（Dijkstra、Floyd、Bellman_Ford、SPFA）、最小生成树（Prim、Kruskal）、深度优先搜索（DFS）以及最大流问题（EK、Dinic、SAP）。每个算法都有详细的代码实现和应用场景说明。
摘要由CSDN通过智能技术生成

图论算法（邻接矩阵）

文章目录

图的创建

#define INF INT_MAX
template<typename T>
class Graph
{
private:
	struct Node
	{
	//存储顶点信息
		T value;
		//存储顶点索引
		int index;
	};
	//顶点数组
	vector<Node>Vert;
	//矩阵
	vector<vector<int>>Matrix;
	//顶点数
	int vertnum;
	//边数
	int edgenum;
public:
	Graph()
	{
		this->vertnum = this->edgenum = 0;
	}
	//通过顶点信息获得对应的索引值
	pair<int, int>Locate(const T& val1, const T& val2)
	{
		int m, n;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == val1)
				m = i;
			if (Vert[i].value == val2)
				n = i;
		}
		return make_pair(m, n);
	}
	void CreateGraph()
	{
		cout << "请输入顶点数：";
		cin >> this->vertnum;
		Vert.resize(this->vertnum);
		Matrix.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << "请输入第" << i + 1 << "个顶点信息：";
			cin >> Vert[i].value;
			Matrix[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
			{
				if (i == j)
					Matrix[i][j] = 0;
				else
					Matrix[i][j] = INF;
			}
		}
		cout << "请输入边数：";
		cin >> this->edgenum;
		T val1, val2;
		int distance;
		for (int i = 0; i < this->edgenum; i++)
		{
			cout << "请输入要连接的顶点：";
			cin >> val1 >> val2;
			pair<int, int>ret = Locate(val1, val2);
			cout << "请输入边长：";
			cin >> distance;
			Matrix[ret.first][ret.second] = distance;
			//若为无向图，添加下面这一条代码
			//Matrix[ret.second][ret.first] = distance;
		}
	}
	void Print()
	{
		cout << "    ";
		for (int i = 0; i < this->vertnum; i++)
			cout << setw(3)<<Vert[i].value << " ";
		cout << endl;
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << setw(3) << Vert[i].value << " ";
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] == INF)
					cout << setw(3) << "oo" << " ";
				else
					cout << setw(3) << Matrix[i][j] << " ";
			}
			cout << endl;
		}
	}
};

拓扑排序

打印入度为0的顶点，然后将该顶点去除，重复上述操作
在这里插入图片描述

void Tology()
	{
		cout << "拓扑排序：";
		//记录每个节点的入度
		vector<int>In;
		In.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++)
		{
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF)
					In[j]++;
			}
		}
		//队列
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
		//入度为0，则入队列
			if (In[i] == 0)
			{
				q.push(i);
				cout << Vert[i].value << " ";
				break;
			}
		}
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			//更新各个顶点的入度
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					In[i]--;
					if (In[i] == 0)
					{
						cout << Vert[i].value << " ";
						q.push(i);
					}
				}
			}
		}
		cout << endl;
	}

无权最短路径

使用DFS算法，不考虑边长，获得各个顶点到起点的距离
在这里插入图片描述

//打印路径
void print_path(vector<int>& pre, int x)
	{
		if (x == pre[x])
		{
			cout << Vert[x].value << " -> ";
			return;
		}
		print_path(pre, pre[x]);
		cout << Vert[x].value << " -> ";
	}
	void NoWeight()
	{
		cout << "请输入起点：";
		T start;
		cin >> start;
		//记录距离的数组
		vector<int>dist;
		//用于判断是否已入队
		vector<int>visit;
		vector<int>pre;
		dist.resize(this->vertnum, -1);
		visit.resize(this->vertnum, 0);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				visit[i] = 1;
				q.push(i);
				break;
			}
		}
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
				//更新dist数组
					if (visit[i] == 0)
					{
						dist[i] = dist[top] + 1;
						visit[i] = 1;
						pre[i] = top;
						q.push(i);
					}
				}
			}
		}
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << Vert[i].value << " " << dist[i] << " ";
			print_path(pre,i);
			cout << "end"<<endl;
		}
	}

Dijkstra算法

在这里插入图片描述
具体理论可看以下链接：
Dijkstra算法原理（转自平凡的L同学）

void Dijkstra()
	{
		T start;
		cout << "请输入起点：";
		cin >> start;
		vector<int>dist;
		vector<int>visit;
		vector<int>pre;
		dist.resize(this->vertnum, INF);
		visit.resize(this->vertnum, 0);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				visit[i] = 1;
				q.push(i);
				break;
			}
		}
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
				//更新dist数组
					if (dist[top] + Matrix[top][i] < dist[i])
					{
						dist[i] = dist[top] + Matrix[top][i];
						pre[i] = top;
						//判断是否入队
						if (visit[i] == 0)
						{
							visit[i] = 1;
							q.push(i);
						}
					}
				}
			}
		}
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << Vert[i].value << " " << dist[i] << " ";
			print_path(pre, i);
			cout << "end" << endl;
		}
	}

Floyd算法

获得每个顶点到其他顶点的距离
最短路径模板+解析(Floyd算法）（转自coderyzh）

void Floyd()
	{
		vector<vector<int>>capacity;
		capacity.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
		{
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
				capacity[i][j] = Matrix[i][j];
		}
		//判断是否存在从i到k再从k到j的路径，使capacity[i][j]变小
		for (int k = 0; k < this->vertnum; k++)
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				for (int j = 0; j < this->vertnum; j++)
				{
					if (capacity[i][k] != INF && capacity[k][j] != INF && capacity[i][k] + capacity[k][j] < capacity[i][j])
					{
						capacity[i][j] = capacity[i][k] + capacity[k][j];
					}
				}
			}
		}
		cout << "    ";
		for (int i = 0; i < this->vertnum; i++)
			cout << setw(3) << Vert[i].value << " ";
		cout << endl;
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << setw(3) << Vert[i].value << " ";
			for (int j = 0; j < this->vertnum; j++)
			{
				if (capacity[i][j] == INF)
					cout << setw(3) << "oo" << " ";
				else
					cout << setw(3) <<capacity[i][j] << " ";
			}
			cout << endl;
		}
	}

Bellman_Ford算法

获得存在负值边的图的最短路径
图算法：2、计算带有负权值的单源最短路径:Bellman-Ford算法（转自天地一扁舟）
在这里插入图片描述
在这里插入图片描述
第一个图有负回路，第二个图无负回路

void Bellman_Ford()
	{
		vector<int>dist;
		vector<int>pre;
		dist.resize(this->vertnum, INF);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		T start;
		cout << "请输入起点：";
		cin >> start;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				break;
			}
		}
		//松弛操作
		for (int k = 0; k < this->vertnum - 1; k++)
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				for (int j = 0; j < this->vertnum; j++)
				{
					if (Matrix[i][j] != 0 && Matrix[i][j] != INF && dist[i] != INF)
					{
						if (dist[i] + Matrix[i][j] < dist[j])
						{
							pre[j] = i;
							dist[j] = dist[i] + Matrix[i][j];
						}
					}
				}
			}
		}
		bool flag = false;
		//松弛操作后，若还能松弛，则说明肯定存在负回路
		for (int i = 0; i < this->vertnum; i++)
		{
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF && dist[i] != INF)
				{
					if (dist[i] + Matrix[i][j] < dist[j])
					{
						flag = true;
						break;
					}
				}
			}
			if (flag)
				break;
		}
		if (flag)
			cout << "存在负环路" << endl;
		else
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				cout << Vert[i].value << " " << dist[i] << " ";
				print_path(pre, i);
				cout << "end" << endl;
			}
		}
	}

SPFA算法

获得存在负值边的图的最短路径，与Bellman_Ford算法类似，但使用队列对Bellman_Ford进行改进
最短路径问题—SPFA算法详解（转自Ouyang_Lianjun
）

void SPFA()
	{
		vector<int>dist;
		vector<int>pre;
		//记录入队次数
		vector<int>count;
		dist.resize(this->vertnum, INF);
		pre.resize(this->vertnum);
		count.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		T start;
		cout << "请输入起点：";
		cin >> start;
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				count[i]++;
				q.push(i);
				break;
			}
		}
		bool flag = false;
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					if (dist[top] + Matrix[top][i] < dist[i])
					{
						dist[i] = dist[top] + Matrix[top][i];
						pre[i] = top;
						count[i]++;
						q.push(i);
						//入队次数等于顶点数时，说明存在负回路
						if (count[i] == this->vertnum)
						{
							flag = true;
							break;
						}
					}
				}
			}
			if (flag)
				break;
		}
		if (flag)
			cout << "存在负环路" << endl;
		else
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				cout << Vert[i].value << " " << dist[i] << " ";
				print_path(pre, i);
				cout << "end" << endl;
			}
		}
	}

Prim算法

生成最小树的一种方法
最小生成树Prim算法理解（转自qwurey）

void Prim()
	{
		T start;
		cout << "请输入起点：";
		cin >> start;
		vector<int>dist;
		vector<int>pre;
		dist.resize(this->vertnum, INF);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		int top = 0;
		int count = 0;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = -1;
				top = i;
				count++;
				break;
			}
		}
		int ans = 0;
		while (count < this->vertnum)
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i]!=-1&&Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					if (Matrix[top][i] < dist[i])
					{
						dist[i] = Matrix[top][i];
						pre[i] = top;
					}
				}
			}
			int minz = INF;
			int nextpos;
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i] != -1 && dist[i] < minz)
				{
					minz = dist[i];
					nextpos = i;
				}
			}
			if (minz == INF)
				break;
			else
			{
				cout << Vert[pre[nextpos]].value << " -- " << Vert[nextpos].value << ":" << minz << endl;
				ans += minz;
				top = nextpos;
				dist[top] = -1;
				count++;
			}
		}
		cout << ans << endl;
	}

Kruskal算法

生成最小树的一种方法，运用到并查集的知识
最小生成树（kruskal算法）（转自Superb_Day
）

//并查集查找和合并操作
int Find(vector<int>& pre, int x)
	{
		if (x == pre[x])
			return x;
		int root = x;
		while (root != pre[root])
			root = pre[root];
		int j = x;
		while (j != root)
		{
			int k = pre[j];
			pre[j] = root;
			j = k;
		}
		return root;
	}
	bool Union(vector<int>& pre, int root1, int root2)
	{
		root1 = Find(pre, root1);
		root2 = Find(pre, root2);
		if (root1 == root2)
			return  false;
		pre[root1] = root2;
		return true;
	}
	void Kruskal()
	{
		struct node
		{
			int from;
			int to;
			int distance;
		};
		//定义排序方式
		struct cmp
		{
			bool operator()(node a, node b)
			{
				return a.distance > b.distance;
			}
		};
		//优先队列,根据距离排序，队列最前面的是距离最小的
		priority_queue<node, vector<node>, cmp>q;
		vector<int>pre;
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = i;
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF)
				{
					node pnew;
					pnew.from = i;
					pnew.to = j;
					pnew.distance = Matrix[i][j];
					q.push(pnew);
				}
			}
		}
		int ans = 0;
		while (!q.empty())
		{
			node top = q.top();
			q.pop();
			if (Union(pre, top.from, top.to))
			{
				ans += top.distance;
				cout << Vert[top.from].value << " -- " << Vert[top.to].value << ":" << top.distance << endl;
			}
			bool flag = false;
			for (int i = 1; i < this->vertnum; i++)
			{
			//判断是否有不再同一个集合的顶点，有的话继续进行合并
				if (Find(pre, i) != Find(pre, 0))
				{
					flag = true;
				}
			}
			if (!flag)
				break;
		}
		cout << ans << endl;
	}

DFS

图的深度搜索算法
图的广度优先搜索（BFS）和深度优先搜索（DFS）算法解析（转自Chida15）

void DFS()
	{
		T start;
		cout << "请输入起点：";
		cin >> start;
		vector<int>visit;
		visit.resize(this->vertnum, 0);
		stack<int>s;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				visit[i] = 1;
				s.push(i);
				cout << Vert[i].value << " ";
				break;
			}
		}
		while (!s.empty())
		{
			int top = s.top();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
				//判断是否已入队
					if (visit[i] == 0)
					{
						s.push(i);
						visit[i] = 1;
						cout << Vert[i].value << " ";
						break;
					}
				}
			}
			if (top == s.top())
				s.pop();
		}
		cout << endl;
	}

最大流之EK算法

求最大流的两种算法 EK算法和dinic算法（转自一枚研究生er）

//广度优先算法，先判断是否存在从起点到终点的路径
int bfs(vector<vector<int>>& capacity, vector<int>& pre, vector<int>& flow, int start, int end)
	{
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = -1;
			flow[i] = INF;
		}
		pre[start] = start;
		queue<int>q;
		q.push(start);
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			if (top == end)
				break;
			for (int i = 0; i < this->vertnum; i++)
			{
				if (pre[i]==-1&&capacity[top][i] != 0 && capacity[top][i] != INF)
				{
				//更新流的长度
					flow[i] = min(flow[top], capacity[top][i]);
					pre[i] = top;
					q.push(i);
				}
			}
		}
		if (pre[end] == -1)
			return -1;
		return flow[end];
	}
	void EK()
	{
		vector<vector<int>>capacity;
		vector<int>pre;
		vector<int>flow;
		capacity.resize(this->vertnum);
		pre.resize(this->vertnum);
		flow.resize(this->vertnum, INF);
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = i;
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
			{
				capacity[i][j] = Matrix[i][j];
			}
		}
		T start, end;
		cout << "请输入起点和终点：";
		cin >> start >> end;
		pair<int, int>ret = Locate(start, end);
		int increment = 0;
		int ans = 0;
		while (1)
		{
			increment = bfs(capacity, pre, flow, ret.first, ret.second);
			if (increment == -1)
				break;
			ans += increment;
			int k = ret.second;
			while (k != ret.first)
			{
				capacity[pre[k]][k] -= increment;
				capacity[k][pre[k]] += increment;
				k = pre[k];
			}
		}
		cout << ans << endl;
	}

最大流之Dinic算法

求最大流的两种算法 EK算法和dinic算法（转自一枚研究生er）

//广度优先算法，计算每个顶点到起点的无变最短路径
bool bfs1(vector<vector<int>>& capacity, vector<int>& dist, int start, int end)
	{
		for (int i = 0; i < this->vertnum; i++)
			dist[i] = -1;
		dist[start] = 0;
		queue<int>q;
		q.push(start);
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i] == -1 && capacity[top][i] != 0 && capacity[top][i] != INF)
				{
					dist[i] = dist[top] + 1;
					q.push(i);
				}
			}
		}
		if (dist[end] == -1)
			return false;
		return true;
	}
	int dfs(vector<vector<int>>& capacity, vector<int>& dist, int now, int end, int value)
	{
		if (now == end)
			return value;
		int minz = INF;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (dist[i] == dist[now] + 1 && capacity[now][i] != 0 && capacity[now][i] != INF)
			{
				if (minz = dfs(capacity, dist, i, end, min(capacity[now][i], value)))
				{
					capacity[now][i] -= minz;
					capacity[i][now] += minz;
					return minz;
				}
			}
		}
		return 0;
	}
	void Dinic()
	{
		vector<vector<int>>capacity;
		vector<int>dist;
		capacity.resize(this->vertnum);
		dist.resize(this->vertnum, -1);
		for (int i = 0; i < this->vertnum; i++)
		{
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
				capacity[i][j] = Matrix[i][j];
		}
		T start, end;
		cout << "请输入起点和终点：";
		cin >> start >> end;
		pair<int, int>ret = Locate(start, end);
		int ans = 0;
		while (bfs1(capacity, dist, ret.first, ret.second))
		{
			ans += dfs(capacity, dist, ret.first, ret.second, INF);
		}
		cout << ans << endl;
	}

最大流之SAP算法

SAP是对Dinic算法的改进，通过增加一个层数组，当出现断层时，直接退出
网络流最大流的sap()算法（转自shiqi_614）

void SAP()
	{
		vector<vector<int>>capacity;
		vector<int>gap;
		vector<int>dist;
		vector<int>pre;
		vector<int>flow;
		capacity.resize(this->vertnum);
		gap.resize(this->vertnum, 0);
		dist.resize(this->vertnum, -1);
		pre.resize(this->vertnum);
		flow.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = i;
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
				capacity[i][j] = Matrix[i][j];
		}
		T start, end;
		cout << "请输入起点和终点：";
		cin >> start >> end;
		pair<int, int>ret = Locate(start, end);
		dist[ret.second] = 0;
		queue<int>q;
		q.push(ret.second);
		gap[0]++;
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i] == -1 && capacity[i][top] != 0 && capacity[i][top] != INF)
				{
					dist[i] = dist[top] + 1;
					gap[dist[i]]++;
					q.push(i);
				}
			}
		}
		if (dist[ret.first] == -1)
			return;
		int ans = 0;
		int top = ret.first;
		int i, j;
		while (dist[ret.first] < this->vertnum)
		{
			bool flag = false;
			flow[ret.first] = INF;
			for (i = 0; i < this->vertnum; i++)
			{
				if (dist[i] + 1 == dist[top] && dist[i] >= 0 && capacity[top][i] != 0 && capacity[top][i] != INF)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				flow[i] = min(flow[top], capacity[top][i]);
				pre[i] = top;
				top = i;
				if (top == ret.second)
				{
					ans += flow[ret.second];
					int k = ret.second;
					while (k != ret.first)
					{
						capacity[pre[k]][k] -= flow[ret.second];
						capacity[k][pre[k]] += flow[ret.second];
						k = pre[k];
					}
					top = ret.first;
					for (int i = 0; i < this->vertnum; i++)
						flow[i] = INF;
				}
			}
			else
			{
				int minz = INF;
				for (j = 0; j < this->vertnum; j++)
				{
					if (dist[j] + 1 < minz && dist[j] >= 0 && capacity[top][j] != 0 && capacity[top][j] != INF)
					{
						minz = dist[j] + 1;
					}
				}
				gap[dist[top]]--;
				if (gap[dist[top]] == 0)
					break;
				dist[top] = minz;
				gap[minz]++;
				if (top != ret.first)
					top = pre[top];
			}
		}
		cout << ans << endl;
	}
	void dfs(vector<vector<int>>& capacity, stack<int>& s, int start) {
		for (int i = 0; i < this->vertnum; i++) {
			if (capacity[start][i] != 0) {
				capacity[start][i] = capacity[i][start] = 0;
				s.push(i);
				dfs(capacity, s, i);
				break;
			}
		}
	}
	void Fleury(vector<vector<int>>& capacity, stack<int>& s, int start)
	{
		s.push(start);
		while (!s.empty()) 
		{
			bool flag = false;
			for (int i = 0; i < this->vertnum; i++) 
			{
				if (capacity[s.top()][i] != 0)
				{
					flag = true;
					break;
				}
			}
			if (flag) {
				dfs(capacity, s, s.top());
			}
			else {
				cout << Vert[s.top()].value << " ";
				s.pop();
			}
		}
	}

欧拉回路

遍历每条边，如何回到起点的为欧拉回路；
遍历每条边的为欧拉路

void dfs(vector<vector<int>>& capacity, stack<int>& s, int start) {
		for (int i = 0; i < this->vertnum; i++) {
			if (capacity[start][i] != 0) {
				capacity[start][i] = capacity[i][start] = 0;
				s.push(i);
				dfs(capacity, s, i);
				break;
			}
		}
	}
	void Fleury(vector<vector<int>>& capacity, stack<int>& s, int start)
	{
		s.push(start);
		while (!s.empty()) 
		{
			bool flag = false;
			for (int i = 0; i < this->vertnum; i++) 
			{
				if (capacity[s.top()][i] != 0)
				{
					flag = true;
					break;
				}
			}
			if (flag) {
				dfs(capacity, s, s.top());
			}
			else {
				cout << Vert[s.top()].value << " ";
				s.pop();
			}
		}
	}
	void Euler() {
		vector<vector<int>>capacity;
		vector<int>In;
		capacity.resize(this->vertnum);
		In.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++) {
			capacity[i].resize(this->vertnum, 0);
			for (int j = 0; j < this->vertnum; j++) {
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF) {
					capacity[i][j] = 1;
					In[i]++;
					In[j]++;
				}
			}
		}
		int num = 0;
		for (int i = 0; i < this->vertnum; i++){
			if (In[i] % 2 == 1)
				num++;
		}
		if (num == 0 || num == 2) {
			if (num == 0)
				cout << "存在欧拉回路：" << endl;
			else
				cout << "存在欧拉路：" << endl;
			T start;
			cout << "请输入起点：";
			cin >> start;
			stack<int>s;
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Vert[i].value == start)
				{
					Fleury(capacity, s, i);
					break;
				}
			}
		}
		else
			cout << "不存在欧拉路或欧拉回路" << endl;
	}```

总结

#include<iostream>
using namespace std;
#include<string>
#include<queue>
#include<iomanip>
#include<stack>
#define INF INT_MAX
template<typename T>
class Graph
{
private:
	struct Node
	{
		T value;
		int index;
	};
	vector<Node>Vert;
	vector<vector<int>>Matrix;
	int vertnum;
	int edgenum;
public:
	Graph()
	{
		this->vertnum = this->edgenum = 0;
	}
	pair<int, int>Locate(const T& val1, const T& val2)
	{
		int m, n;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == val1)
				m = i;
			if (Vert[i].value == val2)
				n = i;
		}
		return make_pair(m, n);
	}
	void CreateGraph()
	{
		cout << "请输入顶点数：";
		cin >> this->vertnum;
		Vert.resize(this->vertnum);
		Matrix.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << "请输入第" << i + 1 << "个顶点信息：";
			cin >> Vert[i].value;
			Matrix[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
			{
				if (i == j)
					Matrix[i][j] = 0;
				else
					Matrix[i][j] = INF;
			}
		}
		cout << "请输入边数：";
		cin >> this->edgenum;
		T val1, val2;
		int distance;
		for (int i = 0; i < this->edgenum; i++)
		{
			cout << "请输入要连接的顶点：";
			cin >> val1 >> val2;
			pair<int, int>ret = Locate(val1, val2);
			cout << "请输入边长：";
			cin >> distance;
			Matrix[ret.first][ret.second] = distance;
			Matrix[ret.second][ret.first] = distance;
		}
	}
	void Print()
	{
		cout << "    ";
		for (int i = 0; i < this->vertnum; i++)
			cout << setw(3)<<Vert[i].value << " ";
		cout << endl;
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << setw(3) << Vert[i].value << " ";
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] == INF)
					cout << setw(3) << "oo" << " ";
				else
					cout << setw(3) << Matrix[i][j] << " ";
			}
			cout << endl;
		}
	}
	void Tology()
	{
		cout << "拓扑排序：";
		vector<int>In;
		In.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++)
		{
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF)
					In[j]++;
			}
		}
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (In[i] == 0)
			{
				q.push(i);
				cout << Vert[i].value << " ";
				break;
			}
		}
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					In[i]--;
					if (In[i] == 0)
					{
						cout << Vert[i].value << " ";
						q.push(i);
					}
				}
			}
		}
		cout << endl;
	}
	void print_path(vector<int>& pre, int x)
	{
		if (x == pre[x])
		{
			cout << Vert[x].value << " -> ";
			return;
		}
		print_path(pre, pre[x]);
		cout << Vert[x].value << " -> ";
	}
	void NoWeight()
	{
		cout << "请输入起点：";
		T start;
		cin >> start;
		vector<int>dist;
		vector<int>visit;
		vector<int>pre;
		dist.resize(this->vertnum, -1);
		visit.resize(this->vertnum, 0);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				visit[i] = 1;
				q.push(i);
				break;
			}
		}
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					if (visit[i] == 0)
					{
						dist[i] = dist[top] + 1;
						visit[i] = 1;
						pre[i] = top;
						q.push(i);
					}
				}
			}
		}
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << Vert[i].value << " " << dist[i] << " ";
			print_path(pre,i);
			cout << "end"<<endl;
		}
	}
	void Dijkstra()
	{
		T start;
		cout << "请输入起点：";
		cin >> start;
		vector<int>dist;
		vector<int>visit;
		vector<int>pre;
		dist.resize(this->vertnum, INF);
		visit.resize(this->vertnum, 0);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				visit[i] = 1;
				q.push(i);
				break;
			}
		}
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					if (dist[top] + Matrix[top][i] < dist[i])
					{
						dist[i] = dist[top] + Matrix[top][i];
						pre[i] = top;
						if (visit[i] == 0)
						{
							visit[i] = 1;
							q.push(i);
						}
					}
				}
			}
		}
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << Vert[i].value << " " << dist[i] << " ";
			print_path(pre, i);
			cout << "end" << endl;
		}
	}
	void Floyd()
	{
		vector<vector<int>>capacity;
		capacity.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
		{
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
				capacity[i][j] = Matrix[i][j];
		}
		for (int k = 0; k < this->vertnum; k++)
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				for (int j = 0; j < this->vertnum; j++)
				{
					if (capacity[i][k] != INF && capacity[k][j] != INF && capacity[i][k] + capacity[k][j] < capacity[i][j])
					{
						capacity[i][j] = capacity[i][k] + capacity[k][j];
					}
				}
			}
		}
		cout << "    ";
		for (int i = 0; i < this->vertnum; i++)
			cout << setw(3) << Vert[i].value << " ";
		cout << endl;
		for (int i = 0; i < this->vertnum; i++)
		{
			cout << setw(3) << Vert[i].value << " ";
			for (int j = 0; j < this->vertnum; j++)
			{
				if (capacity[i][j] == INF)
					cout << setw(3) << "oo" << " ";
				else
					cout << setw(3) <<capacity[i][j] << " ";
			}
			cout << endl;
		}
	}
	void Bellman_Ford()
	{
		vector<int>dist;
		vector<int>pre;
		dist.resize(this->vertnum, INF);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		T start;
		cout << "请输入起点：";
		cin >> start;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				break;
			}
		}
		for (int k = 0; k < this->vertnum - 1; k++)
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				for (int j = 0; j < this->vertnum; j++)
				{
					if (Matrix[i][j] != 0 && Matrix[i][j] != INF && dist[i] != INF)
					{
						if (dist[i] + Matrix[i][j] < dist[j])
						{
							pre[j] = i;
							dist[j] = dist[i] + Matrix[i][j];
						}
					}
				}
			}
		}
		bool flag = false;
		for (int i = 0; i < this->vertnum; i++)
		{
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF && dist[i] != INF)
				{
					if (dist[i] + Matrix[i][j] < dist[j])
					{
						flag = true;
						break;
					}
				}
			}
			if (flag)
				break;
		}
		if (flag)
			cout << "存在负环路" << endl;
		else
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				cout << Vert[i].value << " " << dist[i] << " ";
				print_path(pre, i);
				cout << "end" << endl;
			}
		}
	}
	void SPFA()
	{
		vector<int>dist;
		vector<int>pre;
		vector<int>count;
		dist.resize(this->vertnum, INF);
		pre.resize(this->vertnum);
		count.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		T start;
		cout << "请输入起点：";
		cin >> start;
		queue<int>q;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = 0;
				count[i]++;
				q.push(i);
				break;
			}
		}
		bool flag = false;
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					if (dist[top] + Matrix[top][i] < dist[i])
					{
						dist[i] = dist[top] + Matrix[top][i];
						pre[i] = top;
						count[i]++;
						q.push(i);
						if (count[i] == this->vertnum)
						{
							flag = true;
							break;
						}
					}
				}
			}
			if (flag)
				break;
		}
		if (flag)
			cout << "存在负环路" << endl;
		else
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				cout << Vert[i].value << " " << dist[i] << " ";
				print_path(pre, i);
				cout << "end" << endl;
			}
		}
	}
	void Prim()
	{
		T start;
		cout << "请输入起点：";
		cin >> start;
		vector<int>dist;
		vector<int>pre;
		dist.resize(this->vertnum, INF);
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
			pre[i] = i;
		int top = 0;
		int count = 0;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				dist[i] = -1;
				top = i;
				count++;
				break;
			}
		}
		int ans = 0;
		while (count < this->vertnum)
		{
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i]!=-1&&Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					if (Matrix[top][i] < dist[i])
					{
						dist[i] = Matrix[top][i];
						pre[i] = top;
					}
				}
			}
			int minz = INF;
			int nextpos;
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i] != -1 && dist[i] < minz)
				{
					minz = dist[i];
					nextpos = i;
				}
			}
			if (minz == INF)
				break;
			else
			{
				cout << Vert[pre[nextpos]].value << " -- " << Vert[nextpos].value << ":" << minz << endl;
				ans += minz;
				top = nextpos;
				dist[top] = -1;
				count++;
			}
		}
		cout << ans << endl;
	}
	int Find(vector<int>& pre, int x)
	{
		if (x == pre[x])
			return x;
		int root = x;
		while (root != pre[root])
			root = pre[root];
		int j = x;
		while (j != root)
		{
			int k = pre[j];
			pre[j] = root;
			j = k;
		}
		return root;
	}
	bool Union(vector<int>& pre, int root1, int root2)
	{
		root1 = Find(pre, root1);
		root2 = Find(pre, root2);
		if (root1 == root2)
			return  false;
		pre[root1] = root2;
		return true;
	}
	void Kruskal()
	{
		struct node
		{
			int from;
			int to;
			int distance;
		};
		struct cmp
		{
			bool operator()(node a, node b)
			{
				return a.distance > b.distance;
			}
		};
		priority_queue<node, vector<node>, cmp>q;
		vector<int>pre;
		pre.resize(this->vertnum);
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = i;
			for (int j = 0; j < this->vertnum; j++)
			{
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF)
				{
					node pnew;
					pnew.from = i;
					pnew.to = j;
					pnew.distance = Matrix[i][j];
					q.push(pnew);
				}
			}
		}
		int ans = 0;
		while (!q.empty())
		{
			node top = q.top();
			q.pop();
			if (Union(pre, top.from, top.to))
			{
				ans += top.distance;
				cout << Vert[top.from].value << " -- " << Vert[top.to].value << ":" << top.distance << endl;
			}
			bool flag = false;
			for (int i = 1; i < this->vertnum; i++)
			{
				if (Find(pre, i) != Find(pre, 0))
				{
					flag = true;
				}
			}
			if (!flag)
				break;
		}
		cout << ans << endl;
	}
	void DFS()
	{
		T start;
		cout << "请输入起点：";
		cin >> start;
		vector<int>visit;
		visit.resize(this->vertnum, 0);
		stack<int>s;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (Vert[i].value == start)
			{
				visit[i] = 1;
				s.push(i);
				cout << Vert[i].value << " ";
				break;
			}
		}
		while (!s.empty())
		{
			int top = s.top();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Matrix[top][i] != 0 && Matrix[top][i] != INF)
				{
					if (visit[i] == 0)
					{
						s.push(i);
						visit[i] = 1;
						cout << Vert[i].value << " ";
						break;
					}
				}
			}
			if (top == s.top())
				s.pop();
		}
		cout << endl;
	}
	int bfs(vector<vector<int>>& capacity, vector<int>& pre, vector<int>& flow, int start, int end)
	{
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = -1;
			flow[i] = INF;
		}
		pre[start] = start;
		queue<int>q;
		q.push(start);
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			if (top == end)
				break;
			for (int i = 0; i < this->vertnum; i++)
			{
				if (pre[i]==-1&&capacity[top][i] != 0 && capacity[top][i] != INF)
				{
					flow[i] = min(flow[top], capacity[top][i]);
					pre[i] = top;
					q.push(i);
				}
			}
		}
		if (pre[end] == -1)
			return -1;
		return flow[end];
	}
	void EK()
	{
		vector<vector<int>>capacity;
		vector<int>pre;
		vector<int>flow;
		capacity.resize(this->vertnum);
		pre.resize(this->vertnum);
		flow.resize(this->vertnum, INF);
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = i;
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
			{
				capacity[i][j] = Matrix[i][j];
			}
		}
		T start, end;
		cout << "请输入起点和终点：";
		cin >> start >> end;
		pair<int, int>ret = Locate(start, end);
		int increment = 0;
		int ans = 0;
		while (1)
		{
			increment = bfs(capacity, pre, flow, ret.first, ret.second);
			if (increment == -1)
				break;
			ans += increment;
			int k = ret.second;
			while (k != ret.first)
			{
				capacity[pre[k]][k] -= increment;
				capacity[k][pre[k]] += increment;
				k = pre[k];
			}
		}
		cout << ans << endl;
	}
	bool bfs1(vector<vector<int>>& capacity, vector<int>& dist, int start, int end)
	{
		for (int i = 0; i < this->vertnum; i++)
			dist[i] = -1;
		dist[start] = 0;
		queue<int>q;
		q.push(start);
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i] == -1 && capacity[top][i] != 0 && capacity[top][i] != INF)
				{
					dist[i] = dist[top] + 1;
					q.push(i);
				}
			}
		}
		if (dist[end] == -1)
			return false;
		return true;
	}
	int dfs(vector<vector<int>>& capacity, vector<int>& dist, int now, int end, int value)
	{
		if (now == end)
			return value;
		int minz = INF;
		for (int i = 0; i < this->vertnum; i++)
		{
			if (dist[i] == dist[now] + 1 && capacity[now][i] != 0 && capacity[now][i] != INF)
			{
				if (minz = dfs(capacity, dist, i, end, min(capacity[now][i], value)))
				{
					capacity[now][i] -= minz;
					capacity[i][now] += minz;
					return minz;
				}
			}
		}
		return 0;
	}
	void Dinic()
	{
		vector<vector<int>>capacity;
		vector<int>dist;
		capacity.resize(this->vertnum);
		dist.resize(this->vertnum, -1);
		for (int i = 0; i < this->vertnum; i++)
		{
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
				capacity[i][j] = Matrix[i][j];
		}
		T start, end;
		cout << "请输入起点和终点：";
		cin >> start >> end;
		pair<int, int>ret = Locate(start, end);
		int ans = 0;
		while (bfs1(capacity, dist, ret.first, ret.second))
		{
			ans += dfs(capacity, dist, ret.first, ret.second, INF);
		}
		cout << ans << endl;
	}
	void SAP()
	{
		vector<vector<int>>capacity;
		vector<int>gap;
		vector<int>dist;
		vector<int>pre;
		vector<int>flow;
		capacity.resize(this->vertnum);
		gap.resize(this->vertnum, 0);
		dist.resize(this->vertnum, -1);
		pre.resize(this->vertnum);
		flow.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++)
		{
			pre[i] = i;
			capacity[i].resize(this->vertnum);
			for (int j = 0; j < this->vertnum; j++)
				capacity[i][j] = Matrix[i][j];
		}
		T start, end;
		cout << "请输入起点和终点：";
		cin >> start >> end;
		pair<int, int>ret = Locate(start, end);
		dist[ret.second] = 0;
		queue<int>q;
		q.push(ret.second);
		gap[0]++;
		while (!q.empty())
		{
			int top = q.front();
			q.pop();
			for (int i = 0; i < this->vertnum; i++)
			{
				if (dist[i] == -1 && capacity[i][top] != 0 && capacity[i][top] != INF)
				{
					dist[i] = dist[top] + 1;
					gap[dist[i]]++;
					q.push(i);
				}
			}
		}
		if (dist[ret.first] == -1)
			return;
		int ans = 0;
		int top = ret.first;
		int i, j;
		while (dist[ret.first] < this->vertnum)
		{
			bool flag = false;
			flow[ret.first] = INF;
			for (i = 0; i < this->vertnum; i++)
			{
				if (dist[i] + 1 == dist[top] && dist[i] >= 0 && capacity[top][i] != 0 && capacity[top][i] != INF)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				flow[i] = min(flow[top], capacity[top][i]);
				pre[i] = top;
				top = i;
				if (top == ret.second)
				{
					ans += flow[ret.second];
					int k = ret.second;
					while (k != ret.first)
					{
						capacity[pre[k]][k] -= flow[ret.second];
						capacity[k][pre[k]] += flow[ret.second];
						k = pre[k];
					}
					top = ret.first;
					for (int i = 0; i < this->vertnum; i++)
						flow[i] = INF;
				}
			}
			else
			{
				int minz = INF;
				for (j = 0; j < this->vertnum; j++)
				{
					if (dist[j] + 1 < minz && dist[j] >= 0 && capacity[top][j] != 0 && capacity[top][j] != INF)
					{
						minz = dist[j] + 1;
					}
				}
				gap[dist[top]]--;
				if (gap[dist[top]] == 0)
					break;
				dist[top] = minz;
				gap[minz]++;
				if (top != ret.first)
					top = pre[top];
			}
		}
		cout << ans << endl;
	}
	void dfs(vector<vector<int>>& capacity, stack<int>& s, int start) {
		for (int i = 0; i < this->vertnum; i++) {
			if (capacity[start][i] != 0) {
				capacity[start][i] = capacity[i][start] = 0;
				s.push(i);
				dfs(capacity, s, i);
				break;
			}
		}
	}
	void Fleury(vector<vector<int>>& capacity, stack<int>& s, int start)
	{
		s.push(start);
		while (!s.empty()) 
		{
			bool flag = false;
			for (int i = 0; i < this->vertnum; i++) 
			{
				if (capacity[s.top()][i] != 0)
				{
					flag = true;
					break;
				}
			}
			if (flag) {
				dfs(capacity, s, s.top());
			}
			else {
				cout << Vert[s.top()].value << " ";
				s.pop();
			}
		}
	}
	void Euler() {
		vector<vector<int>>capacity;
		vector<int>In;
		capacity.resize(this->vertnum);
		In.resize(this->vertnum, 0);
		for (int i = 0; i < this->vertnum; i++) {
			capacity[i].resize(this->vertnum, 0);
			for (int j = 0; j < this->vertnum; j++) {
				if (Matrix[i][j] != 0 && Matrix[i][j] != INF) {
					capacity[i][j] = 1;
					In[i]++;
					In[j]++;
				}
			}
		}
		int num = 0;
		for (int i = 0; i < this->vertnum; i++){
			if (In[i] % 2 == 1)
				num++;
		}
		if (num == 0 || num == 2) {
			if (num == 0)
				cout << "存在欧拉回路：" << endl;
			else
				cout << "存在欧拉路：" << endl;
			T start;
			cout << "请输入起点：";
			cin >> start;
			stack<int>s;
			for (int i = 0; i < this->vertnum; i++)
			{
				if (Vert[i].value == start)
				{
					Fleury(capacity, s, i);
					break;
				}
			}
		}
		else
			cout << "不存在欧拉路或欧拉回路" << endl;
	}
};
int main()
{
	Graph<int>g;
	g.CreateGraph();
	g.Print();
	//g.Tology();
	//g.NoWeight();
	//g.Dijkstra();
	//g.Floyd();
	//g.Bellman_Ford();
	//g.SPFA();
	//g.Prim();
	//g.Kruskal();
	//g.DFS();
	//g.EK();
	//g.Dinic();
	//g.SAP();
	g.Euler();
	return 0;
}
沉河不浮
关注
专栏目录
邻接矩阵实现图论的相关算法
coder
09-18 964
/* 这一篇文章是关于图论的，采用的是邻接矩阵的方式存储； 重要的算法包括:图的深度遍历、宽度遍历、拓扑排序、关键路径、最小代价生成树、最短路径等问题 必须注意的是：因为是邻接矩阵的存储，需要注意是有向图，无向图，还是网； 对角线的元素为0，对于存在边和不存在边的情况，有向图和无向图处理方法是不一样的！ 如果是有向图的话，那么我们存在边的时候是权值，没有边的时候NoEdge=INF;
图论算法的矩阵实现
VitoZF的博客
09-16 316
图论算法的矩阵写法 BFS_m public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); int start = sc.nextInt(); int matrix[][] = new int[n][n]; for (int i=0;i<n;i++){ for
【图论学习】邻接矩阵/邻接表，Floyed / Djikstra / SPFA 算法求最短路径
最新发布
Sdirws的博客
04-11 864
【图论学习】邻接矩阵/邻接表，Floyed / Djikstra / SPFA 算法求最短路径
数据结构及算法基础 之图（一）邻接矩阵
qigaohua的博客
10-31 554
文章目录一、图结构介绍二、邻接矩阵三、代码实现     一、图结构介绍 图的定义与术语：http://www.360doc.com/content/17/0714/10/17799864_671231489.shtml   二、邻接矩阵   简单理解就是用一个二维矩阵（二维数组）来存储。按照标记来查看此边是否存在。邻接矩阵为每一种情况都做好了空间预存。   适用场景：...
建图方法（邻接矩阵 链式前向星）更新ing
nuoyanli的博客
03-27 1679
u​通常表示起点，​v表示拜访的点，w​表示权值(边的长度之类)。大家代码习惯尽量相同，网上也大致如此。 1 .一维数组 int u[105], v[105], w[105]; #include <bits/stdc++.h> using namespace std; #define N 105// 节点数 #define MAXM 1005// 边数 /* 输入...
头歌数据结构图的邻接矩阵存储及遍历操作
05-26
### 头歌数据结构图的邻接矩阵存储及遍历操作 #### 一、邻接矩阵存储 在数据结构中，图是一种常见的非线性结构，用于表示对象间的关系。根据边是否有方向，图可以分为有向图和无向图。而根据边是否具有权重值，又...
Prim算法计算最小生成树（无向图&邻接矩阵）_算法_数据结构_
10-02
Prim算法的时间复杂度在邻接矩阵表示下是O(V^2)，其中V是顶点的数量。虽然不如Kruskal算法（使用并查集，时间复杂度为O(E log E)，E是边的数量）高效，但在稠密图中，由于边的数量接近V^2，Prim算法仍然是一个不错的...
C++实现数据结构邻接矩阵.zip
04-21
邻接矩阵是图论中一种重要的数据结构，用于表示图中顶点之间的关系。本文将深入探讨C++如何实现邻接矩阵以及其在实际应用中的价值。 首先，让我们了解什么是邻接矩阵。在图论中，一个图由顶点（或节点）和边（连接...
图论邻接矩阵,邻接表的建立c++ 数据结构课程设计
08-15
根据提供的文件信息，本文将详细解释“图论邻接矩阵、邻接表的建立 C++ 数据结构课程设计”中的核心知识点及其实现方法。 ### 图论基础 #### 图的基本概念 在计算机科学中，**图**是一种常用的数据结构，用于表示...
52-图的邻接矩阵存储结构及算法
网络安全
07-17 8101
1. 图的存储结构   通常我们要根据图的逻辑结构来设计图的存储结构来 存储每个顶点的信息，存储每条边的信息。图的存储结构有以下两种：   1. 邻接矩阵存储方法   2.邻接表存储方法 2. 邻接矩阵存储方法   邻接矩阵是表示顶点之间相邻关系的矩阵。设G = （V , E）是具有n（n &amp;amp;amp;amp;amp;amp;amp;amp;gt; 0）个顶点的图，顶点的编号依次为0 ~ n-1。G的邻接矩阵A是n阶方阵，其定义如下...
图论基础知识（四）
Karen_Yu_的博客
12-10 2809
已经介绍了图的顶点、边、有向图、无向图、度、图的同构等知识 链接如下： 图论基础知识（一） 图论基础知识（二） 图论基础知识（三） 好了，今天想介绍的是邻接矩阵以及邻接图（先写一点，之后补充） 邻接矩阵 ————————————同济第六版线性代数第27页例3——————————
基于邻接矩阵的新边的增加
海月的博客
02-22 1594
描述 给定一个无向图，在此无向图中增加一条边。 输入 多组数据，每组m+2行。第一行有两个数字n和m，代表有n个顶点和m条边。顶点编号为1到n。第二行到第m+1行每行有两个数字h和k，代表边依附的两个顶点。第m+2行有两个数字f和g，代表增加的边所依附的两个顶点。当n和m都等于0时，输入结束。 输出 每组数据输出n行。为增加边后的邻接矩阵。每两个数字之间用空格隔开。 ...
6.2_1_邻接矩阵法
猫宁的博客
06-05 963
图的存储–邻接矩阵法 无向图： 是对称矩阵，可以压缩 0表示不连接，1表示连接 有向图: 求度、入度、出度： ​ 无向图：扫描一行或者一列的非0元素，得到度 ​ 有向图：出度，扫描行；入度，扫描列。度 = 入度+出度 邻接矩阵法（网）： ​ 矩阵内标识内标识权值，不存在度则标为无穷大 0或者无穷：表示两个顶点之间不存在路径 适合用于存储稠密度图，否则会有很多浪费 设图G的邻接矩阵为A（矩阵元素为0/1），则An 的元素An [i][j]等于由顶点i到顶点j的长度为n的路径的数目 ...
【数据结构】 图的邻接矩阵
zgsdlr的博客
11-12 5389
在图的存储方法中，邻接矩阵通过数组对图的信息进行存储。 基本思路 使用邻接矩阵前，需要开一个一维数组数组，以存储各个顶点的数据（数组的编号与邻接矩阵中顶点的编号一一对应）；同时，还需要一个标记顶点是否被访问的一维数组，用来表示图中顶点是否被访问。【其中，标记顶点是否被访问的数组使用全局变量】 邻接矩阵为n*n方阵（二维数组），用来表示图中顶点间的连通关系（两顶点连通，数组值为1；两顶点不连通，数组值为0）。因此邻接矩阵edge数组的大小取决于图中顶点的数量。 邻接矩阵构造前，需要对标记数组、邻接矩阵edge
图论学习笔记——图的矩阵
计算机小白努力学习
05-06 4722
图的矩阵表示 一个图G= (V,E)由它的顶点与边之间的关联关系唯一确定,也由它的顶点对之间的邻接关系唯- -确定.图的这种关系均可以用矩阵来描述,分别称为G的关联矩阵与邻接矩阵.--个图的矩阵表示不仅仅是给出了图的一种表示方法，重要的是可通过对这些矩阵的讨论得到有关图的若干性质.此外,在图论的应用中，图的矩阵表示也具有重要的作用.。 关联矩阵 邻接矩阵 性质 ...
图的邻接矩阵算法
阿牛哥的博客
05-15 3082
无向图的邻接矩阵是关于左上右下对角线对称的，有向图不一定对称 先得理解矩阵描述的图，或者明白图的矩阵描述概念。 图的邻接矩阵存储结构 #define MAX 100 typedef struct{ char vexs[MAX]; //顶点表 int arc[MAX][MAX];//邻接矩阵，也就是边的关系表 int numVertexes,numEdges;//图中的定点数和边数 }MGaph; 根据邻接矩阵的定义，可得到建立图的邻接矩阵算法。 算法描述：首先得到图的顶点数和边数、然后按照顶.
数据结构与算法-图论 邻接矩阵【十四】
Riptide
08-01 3497
图的定义 数据之间的关系可能是多种的，逻辑结构上来讲，分几种： 线性结构 非线性结构 【包括三种: 集合结构，树形结构，图状结构】 线性结构 线性结构的几种表现方式，前面大部分都了解过了： 线性表 （List） 栈（特殊的线性表） 【先进后出】 （Stack） 队列（特殊的线性表）【先进先出】 （Queue） 字符串，数组，广义表【广义表是特殊的线性表，广义表的元素可以是子表，子表的元素也可以是子表；如果广义表的每个元素都是原子，它就变成了线性表】 非线性结构 非线性结构中的 树(clic
图邻接矩阵算法
孤独的博客
11-16 3180
邻接矩阵比较好理解，这里就不记录了，主要是邻接表，比较难理解，       邻接表存储类型定义：   typedef struct ANode{ int adjvex; //该边的终点编号 struct ANode *nextarc; //指向下一条边的指针 InfoType weight; //该边的权值等信息} ArcNode; typedef struct Vnode{ Vertex data; //顶点信息 ArcNo
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值