图论 c++实现

最新推荐文章于 2024-07-10 20:24:45 发布
最新推荐文章于 2024-07-10 20:24:45 发布
阅读量476 收藏 1
点赞数
分类专栏： 数据结构 文章标签： c++ 图论 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhaida/article/details/128570253
版权
本文介绍了图的概念，包括邻接矩阵和邻接表两种表示方法，以及无环图的定义。接着详细讲解了BFS和DFS遍历算法，包括伪代码和实现。此外，讨论了最短路径问题，如贝尔曼-福特算法和Dijkstra算法，以及如何在有向无环图(DAG)中寻找最短路径。最后，提到了最小生成树问题，介绍了Kruskal和Prim算法的实现。
摘要由CSDN通过智能技术生成

概述

图，是用来对对象之间的关系建模的数学结构。图是由由边连接起来的顶点组成的。
在这里插入图片描述

术语

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
circuit与cycle的区别：
circuit（简单回路）：起点终点相同。
cycle（圈）：起点到终点所经过的顶点除起点终点相同外，其余顶点各异，又称简单回路。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
有向无环图
在这里插入图片描述

邻接矩阵

在这里插入图片描述

#pragma once
#include <iostream>

namespace simple_graph_adjmateix
{
	class simple_graph
	{
		int** vertex_matrix;
		int num_of_vertices, num_of_edges;
	public:
		simple_graph(int _num_of_vertices = 10)
			:num_of_vertices(_num_of_vertices)
		{
			num_of_edges = 0;
			vertex_matrix = new int* [_num_of_vertices];

			for (size_t i = 0; i < _num_of_vertices; i++)
			{
				vertex_matrix[i] = new int[_num_of_vertices];
			}

			for (size_t i = 0; i < num_of_vertices; i++)
			{
				for (size_t j = 0; j < num_of_vertices; ++j)
				{
					vertex_matrix[i][j] = INT_MAX;
				}
			}
		}

		~simple_graph()
		{
			for (size_t i = 0; i < num_of_vertices; i++)
			{
				delete[] vertex_matrix[i];
			}
			delete[] vertex_matrix;
		}

		void add_edge(int v1, int v2, int weight)
		{
			if (vertex_matrix[v1 - 1][v2 - 1] == INT_MAX)
				num_of_edges++;
			vertex_matrix[v1 - 1][v2 - 1] = weight;
		}

		void del_edge(int v1, int v2)
		{
			if (vertex_matrix[v1 - 1][v2 - 1] != INT_MAX)
				num_of_edges--;
			vertex_matrix[v1 - 1][v2 - 1] = INT_MAX;
		}

		void print_graph()
		{
			for (size_t i = 0; i < num_of_vertices; i++)
			{
				for (size_t j = 0; j < num_of_vertices; ++j)
				{
					if (vertex_matrix[i][j] != INT_MAX)
					{
						std::cout << vertex_matrix[i][j];
					}
					else
					{
						std::cout << "I";
					}
				}
				std::cout << std::endl;
			}
		}
	};
}

邻接表

在这里插入图片描述

#pragma once

#include <list>
#include <string>
#include <vector>
enum NODE_COLOR
{
	WHITE,
};

namespace simple_graph_adjlist
{
	struct vertex
	{
		int node_id;
		std::string value;
		std::vector< std::pair<vertex*, int> > adj_list;//链表

		NODE_COLOR color = WHITE;
		int distance = INT_MAX;
		vertex* predecessor = NULL;

		vertex() {}

		vertex(int _id, std::string _value = "")
			:node_id(_id), value(_value)
		{
		}

		void print_vertex()
		{
		}
	};

	class simple_graph
	{
		std::vector<vertex*> vertex_list;//储存所有的顶点
	public:
		simple_graph() {}
		~simple_graph() {}
		void add_node(int _node_id, std::string value = "")
		{
			for (auto& var : vertex_list)
			{
				if (var->node_id == _node_id)
				{
					throw;
				}
			}
			vertex_list.push_back(new vertex(_node_id, value));
		}
		void add_edge(int v1_id, int v2_id, int weight = 0)
		{
			vertex* v1 = NULL;
			vertex* v2 = NULL;

			bool found_v1 = false;
			bool found_v2 = false;

			//先找到两个顶点
			for (auto& var : vertex_list)
			{
				if (var->node_id == v1_id)
				{
					v1 = var;
					found_v1 = true;
				}

				if (var->node_id == v2_id)
				{
					v2 = var;
					found_v2 = true;
				}

				if (found_v1 && found_v2)
					break;
			}

			if (found_v1 && found_v2)
			{
				bool edge_already_exist = false;

				//遍历顶点v1判断是否已经连线
				for (auto& var : v1->adj_list)
				{
					if (var.first->node_id == v2_id)
					{
						edge_already_exist = true;
						throw;
						break;
					}
				}
				if (!edge_already_exist)
				{
					v1->adj_list.push_back(std::make_pair(v2, weight));
				}
			}
			else
			{
				throw;
			}
		}

		void print_graph() {}

		void print_nodes() {}
	};
}

稠密图与稀疏图

在这里插入图片描述

在这里插入图片描述

BFS

在这里插入图片描述
在这里插入图片描述

BFS伪代码

在这里插入图片描述
图示：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

vertex* initialize_and_find_vertex(int vertex_id)
		{
			vertex* v1 = NULL;
			for (auto& vertex1:vertex_list)
			{
				vertex1->color = WHITE;
				vertex1->distance = -1;
				vertex1->predecessor = NULL;

				if (vertex1->node_id == vertex_id)
					v1 = vertex1;
			}
			return v1;
		}
		
void BFS(simple_graph& graph, int source_vertex_id)
	{
		std::queue<vertex*> q;
		vertex* v1 = graph.initialize_and_find_vertex(source_vertex_id);
		if (v1 == NULL)
		{
			throw std::runtime_error("error!!!!");
		}
		else
		{
			q.push(v1);
			while (!q.empty())
			{
				vertex* u = q.front();
				q.pop();
				for (auto& v : u->adj_list)
				{
					if (v.first->color == WHITE)
					{
						v.first->color = GRAY;
						v.first->distance = u->distance + 1;
						v.first->predecessor = u;
						q.push((vertex*)v.first);
					}
				}
				u->color = BLACK;
			}
		}
	}

DFS

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void depth_first_search(vertex* v)
		{
			v->color = GRAY;
			std::cout << " ( " << v->node_id;
			for (auto& adj_vetex : v->adj_list)
			{
				if (adj_vetex.first->color = WHITE)
				{
					depth_first_search((vertex*)(adj_vetex.first));
				}
			}
			std::cout << v->node_id << " ) ";
			v->color = BLACK;
		}

void DFS(simple_graph& graph, int source_vertex_id = -1)
	{
		if (source_vertex_id != -1)
		{
			vertex* v1 = graph.initialize_and_find_vertex(source_vertex_id);
			if (v1 = NULL)
			{
				throw std::runtime_error("error!!!!");
			}
			else
			{
				graph.depth_first_search(v1);
				std::cout << std::endl;
			}
		}

		for (auto& v1 : graph.vertex_list)
		{
			if (v1->color == WHITE)
			{
				graph.depth_first_search(v1);
				std::cout << std::endl;
			}
		}
	}

在这里插入图片描述
图进行DFS会得到一棵DFS树（森林），在这个树上 才有了这些概念。对图进行DFS，可以从任意的顶点开始，遍历的方式也是多样的，所以不同的遍历会得到不同的DFS树，进而产生不同的树边，前向边，后向 边，横叉边。所以这4种边，是一个相对的概念。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

分类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
红色是树边，
紫色是后向边，
蓝色是前向边，
黑色是交叉边。

环探测

在这里插入图片描述

Topological sort拓扑排序

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void depth_first_search(vertex* v)
		{
			//access_counter++;
			v->color = GRAY;
			//v->distance = access_counter;
			std::cout << " ( " << v->node_id;
			for (auto& adj_vetex : v->adj_list)
			{
				if (adj_vetex.first->color = WHITE)
				{
					adj_vetex.first->distance = v->distance + 1;
					adj_vetex.first->predecessor = v;
					depth_first_search((vertex*)(adj_vetex.first));
				}
				else if (adj_vetex.first->color == GRAY)
				{
					std::cout << " \n Cycle detected" << std::endl;
				}
			}
			std::cout << v->node_id << " ) ";
			v->color = BLACK;

			if (ADD_TO_PROCESSED_LIST)
				processed_list.push_front(v);
		}
		
void DFS(simple_graph& graph, int source_vertex_id = -1)
	{
		if (source_vertex_id != -1)
		{
			vertex* v1 = graph.initialize_and_find_vertex(source_vertex_id);
			if (v1 = NULL)
			{
				throw std::runtime_error("error!!!!");
			}
			else
			{
				graph.depth_first_search(v1);
				std::cout << std::endl;
			}
		}

		for (auto& v1 : graph.vertex_list)
		{
			if (v1->color == WHITE)
			{
				graph.depth_first_search(v1);
				std::cout << std::endl;
			}
		}
	}
	
void topological_sort(simple_graph& graph, int source_id)
	{
		graph.processed_list.clear();
		graph.ADD_TO_PROCESSED_LIST = true;
		DFS(graph, source_id);
		graph.ADD_TO_PROCESSED_LIST = false;

		for (auto& v : graph.processed_list)
		{
			v->print_vertex();
		}
	}

Strongly connected components

在这里插入图片描述
在一幅无向图中，如果有一条路径连接顶点v和w，则它们就是连通的；然后，在一幅有向图中，如果从顶点v有一条有向路径达到w，则顶点w是从顶点v可达的，但如果从w到达v的路径可能不存在。这两个顶点不是强连通的。

如果两个顶点互相可达，则它们是强连通的。如果一幅有向图中任意两个顶点都是强连通的，则这幅有向图也是强连通的。

有向图中的强连通性是一种顶点之间平等关系，有着以下性质：

自反性： 任意顶点和自己都是强连通的
对称性：如果v和w是强连通的，那么w和v也是强连通的
传递性：如果v和w是强连通的且如果w和x也是强连通的，那么v和x也是强连通的

强连通性将所有顶点分成了一些平等的部分，每个部分都是由相互均为强连通的顶点的最大子集组成的。这些子集称为强连通分量(强连通分支)
在这里插入图片描述
一个含有V个顶点的有向图可能有1~V个强连通分量；一个强连通图只含一个强连通分量；而一个有向无环图中含有V个强连通分量。

有向图的强连通分量和无向图的连通分量不同，因为有向图带有方向，情况略为复杂。
比如考虑上图，{ 0 , 1 , 2 } 和{ 4 , 5 , 6 , 7 } 是两个不同的强连通分量。但是从4有一条路径到另个一分量中的2，同时6也能到8，但是反过来2却不能到4，所以2和4属于不同的分量之中。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void topological_sort(simple_graph& graph, int source_id)
	{
		graph.processed_list.clear();
		graph.ADD_TO_PROCESSED_LIST = true;
		DFS(graph, source_id);
		graph.ADD_TO_PROCESSED_LIST = false;

		for (auto& v : graph.processed_list)
		{
			v->print_vertex();
		}
	}
	
void delete_transpose()
		{
			for (auto& var : grap_transpose_list)
			{
				delete[] var;
			}
		}
		
void strongly_connexted_components(simple_graph& graph)
	{
		graph.PRINT_WHILE_DFS = false;
		topological_sort(graph, -1);
		//获取转置图
		graph.get_transpose();
		graph.PRINT_WHILE_DFS = true;

		//按照顶点在已处理列表中的出现顺序选择顶点
		for (auto& var : graph.processed_list)//拓扑排序的点
		{
			for (auto& var2 : graph.grap_transpose_list)
			{
				if (var->node_id == var2->node_id && var2->color == WHITE)
				{
					graph.depth_first_search(var2);
					std::cout << std::endl;
					break;
				}
			}
		}
		std::cout << "End of printing component list" << std::endl;
		//当构造转置时，我们在堆上创建顶点对象
		//因此我们必须重新存储它，否则将发生内存泄漏
		graph.delete_transpose();
	}

最短路径问题

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

伪代码

在这里插入图片描述
举例：
在这里插入图片描述

贝尔曼福特算法

与迪杰斯特拉算法的区别：
迪杰斯特拉算法是借助贪心思想，每次选取一个未处理的最近的结点，去对与他相连接的边进行松弛操作；贝尔曼福特算法是直接对所有边进行N-1遍松弛操作。

迪杰斯特拉算法要求边的权值不能是负数；贝尔曼福特算法边的权值可以为负数，并可检测负权回路。

在这里插入图片描述

伪代码

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
但是注意如果图中有负权回路的话，最短路就不一定存在了！！！！
负权回路：在一个图里每条边都有一个权值（有正有负)。如果存在一个环（从某个点出发又回到自己的路径），而且这个环上所有权值之和是负数，那这就是一个负权环，也叫负权回路。存在负权回路的图是不能求两点间最短路的，因为只要在负权回路上不断兜圈子，所得的最短路长度可以任意小。

/**
vertex* initialize_and_find_vertex2(int vertex_id)
	{
		vertex* v1 = NULL;
		for (auto& vertex1 : vertex_list)
		{
			vertex1->color = WHITE;
			vertex1->distance = INT_MAX;
			vertex1->predecessor = NULL;

			if (vertex1->node_id == vertex_id)
			{
				v1 = vertex1;
				v1->distance = 0;
			}
		}
		return v1;
	}
 
void relax(vertex* u, vertex* v, int weight)
{
	if (v->distance > u->distance + weight)
	{
		v->distance = u->distance + weight;
		v->predecessor = u;
	}
}

bool sort_path_bellman_ford(simple_graph& graph, int source_vertex_id)
{
	vertex* v1 = graph.initialize_and_find_vertex2(source_vertex_id);

	if (v1 == NULL)
	{
		throw std::runtime_error("error!!!!");
	}
	else
	{
		//外部循环迭代V-1次
		int outer_loop_count = graph.vertex_list.size() - 1;
		for (int i = 0; i < outer_loop_count; ++i)
		{
			//遍历所有边
			for (auto& u : graph.vertex_list)
			{
				for (auto& v : u->adj_list)
				{
					if (u->distance != INT_MAX)
					{
						//调用relax操作
						relax(u, (vertex*)v.first, v.second);
					}
				}
			}
		}
		//检查负权重循环
		for (auto& u : graph.vertex_list)
		{
			for (auto& v : u->adj_list)
			{
				if (u->distance != INT_MAX)
				{
					if (v.first->distance > u->distance + v.second)
					{
						return false;
					}
				}
			}
		}
		return true;
	}
}

DAG最短路径

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void sortest_path_topological(simple_graph& graph, int source_vertex_id)
	{
		//拓扑排序图
		topological_sort(graph, source_vertex_id);
		graph.initialize_and_find_vertex2(source_vertex_id);

		// 在拓扑排序数组上运行最短路径
	// 在这一点上抓住。Processed_list包含拓扑排序的顶点列表
		for (auto& u : graph.vertex_list)
		{
			for (auto& v : u->adj_list)
			{
				if (u->distance != INT_MAX)
				{
					//调用relax操作
					relax(u, (vertex*)v.first, v.second);
				}
			}
		}
	}

Dijkstra算法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
因为优先队列
在这里插入图片描述

伪代码

在这里插入图片描述

void sortest_path_dijkstras(simple_graph& graph, int source_vertex_id)
	{
		vertex* v1 = NULL;
		v1 = graph.initialize_and_find_vertex2(source_vertex_id);
		//T表示已经确定的路径集
		std::vector<vertex*> T;

		bool* state_array = new bool[graph.vertex_list.size()];
		//初始化状态数组
		for (int i = 0; i < graph.vertex_list.size(); ++i)
		{
			state_array[i] = false;
		}
		//优先考虑的对象
		class prioritize
		{
		public:
			bool operator()(std::pair<vertex*, int>& p1,
				std::pair<vertex*, int>& p2)
			{
				return p1.second > p2.second;
			}
		};

		std::priority_queue
			<
			std::pair<vertex*, int>,
			std::vector< std::pair<vertex*, int>>,
			prioritize
			>pq;

		if (v1 == NULL)
		{
			throw std::runtime_error("error!!!!");
		}
		else
		{
			//将源顶点推到pq的起始位置
			pq.push(std::make_pair(v1,v1->distance));
	
			while (!pq.empty())
			{
				vertex* u = NULL;
				int vertex_count = 0;
				bool found_in_current_iter = false;

				//检查virtex是否已经被弹出
				while (!pq.empty())
				{
					u = pq.top().first;
					pq.pop();
					if (!state_array[u->node_id - 1])
					{
						state_array[u->node_id - 1] = true;
						found_in_current_iter = true;
						vertex_count++;
						break;
					}
				}

				if (!found_in_current_iter &&
					vertex_count == graph.vertex_list.size())
				{
					break;
				}
				//检查结束
				// 
				//添加u到已确定的路径列表
				T.push_back(u);

				for (auto& v : u->adj_list)
				{
					if (!state_array[v.first->node_id - 1] &&
						v.first->distance > u->distance + v.second)
					{
						v.first->distance = u->distance + v.second;
						v.first->predecessor = u;
						pq.push(std::make_pair(v.first, v.first->distance));
					}
				}
			}
		}
	}

最小生成树（Minimum spanning tree，MST）

上面的最小路径是有向
最小生成树是无向
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Kruskal’s algorithm（并查集）

伪代码

在这里插入图片描述

int find_set(int* vertex_set, int node_id)
{
	return vertex_set[node_id - 1];
}

void union_sets(int v1_set, int v2_set, int* vertex_set, int n)
{
	for (int i = 0; i < n; ++i)
	{
		if (vertex_set[i] == v2_set)
		{
			vertex_set[i] == v1_set;
		}
	}
}

void mst_kruskals(simple_graph& graph)
{
	//包含顶点集的数组
	//数组的索引与vertex_id-1相同
	int* vertex_set = new int[graph.vertex_list.size()];
	class prioritize
	{
	public:
		bool operator()(edge* a, edge* b)
		{
			return a->weight > b->weight;
		}
	};
	std::priority_queue<edge*, std::vector<edge*>, prioritize> pq;

	//初始化集合
	for (auto& var1 : graph.vertex_list)
	{
		vertex_set[(var1->node_id) - 1] = var1->node_id;
		for (auto& var2 : var1->adj_list)
		{
			// 创建新的边缘并推到pq
			// 记住在不删除顶点对象的情况下声明内存
			pq.push(new edge(var1, var2.first, var2.second));
		}
	}

	std::vector<edge*> min_spaning_tree;
	// std::vector<edge*> ignord_list;
	int min_spaning_tree_cost = 0;

	while (!pq.empty())
	{
		edge* temp = pq.top();
		pq.pop();

		//获取该边的结束顶点所属的集合,去看并查集vertex_set
		int	v1_set = find_set(vertex_set, temp->start->node_id);
		int	v2_set = find_set(vertex_set, temp->end->node_id);

		//比较结束顶点集合
		if (v1_set != v2_set)
		{
			min_spaning_tree.push_back(temp);
			//将结束顶点所属的集合合并
			union_sets(v1_set, v2_set, vertex_set, graph.vertex_list.size());
			min_spaning_tree_cost += temp->weight;
		}
	}

	for (auto& var : min_spaning_tree)
	{
		std::cout << var->start->value << "---" << var->end->value << std::endl;
	}
	std::cout << "Total weight of MST is -" << min_spaning_tree_cost << std::endl;
}

Prims algorithm

在这里插入图片描述
在这里插入图片描述

void mst_prims(simple_graph& graph, int source_vertex_id)
{
	vertex* v1 = graph.initialize_and_find_vertex2(source_vertex_id);

	int* vertex_map = new int[graph.vertex_list.size()];
	//设置顶点初始值
	for (auto& var1 : graph.vertex_list)
	{
		for (auto& var2 : var1->adj_list)
		{
			vertex_map[var1->node_id - 1] = var1->node_id;
			vertex_map[var2.first->node_id - 1] = var2.first->node_id;
		}
	}
	// 我们的最小优先级队列，它将存储边
	class prioritize
	{
	public:
		bool operator()(edge* a, edge* b)
		{
			return a->weight > b->weight;
		}
	};
	std::priority_queue<edge*, std::vector<edge*>, prioritize> pq;

	//在迭代开始前推送离开源顶点的边
	for (auto& var : v1->adj_list)
	{
		// 记得回收边缘列表的内存分配
		// 但是不要删除顶点指针
		pq.push(new edge(v1, var.first, var.second));
	}

	std::vector<edge*> min_spaning_tree;
	int min_spaning_tree_cost = 0;

	while (!pq.empty())
	{
		edge* temp = pq.top();
		pq.pop();

		//获取该边的结束顶点所属的集合,去看并查集vertex_set
		int	v1_set = find_set(vertex_map, temp->start->node_id);
		int	v2_set = find_set(vertex_map, temp->end->node_id);

		//比较结束顶点集合
		if (v1_set != v2_set)
		{
			min_spaning_tree.push_back(temp);
			//如果条件传递v2总是单个顶点
			vertex_map[temp->end->node_id - 1] = v1_set;
			min_spaning_tree_cost += temp->weight;

			//和边缘离开
			for (auto& var : temp->end->adj_list)
			{
				pq.push(new edge(temp->end, var.first, var.second));
			}
		}
	}

	for (auto& var : min_spaning_tree)
	{
		std::cout << var->start->value << "---" << var->end->value << std::endl;
	}
	std::cout << "Total weight of MST is -" << min_spaning_tree_cost << std::endl;

}
yhaida
关注
专栏目录
C++图论
PanDaoxi
12-26 481
C++图论！
C++基础图论算法大集合 （图论，看我就行了）
qq_43514659的博客
04-06 5794
图论搜索技术深度优先搜索 （应用——求重心）广度优先搜索 （应用——图中的层次遍历）有向图的拓扑排序最短路问题Dijkstra算法（朴素版）Dijkstra算法 （堆优化）bellman_ford算法spfa算法spfa判负权Floyd算法最小生成树系列prim算法二分图判断二分图（染色法）二分图的最大匹配 搜索技术 深度优先搜索 （应用——求重心） 重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。 本题的本质是树的dfs， 每次dfs可以确定以u
c++基础算法（认识图论）
最新发布
sjzwer_的博客
07-10 888
图论是数学中的一个分支，研究图的性质和图的相关问题。图是由节点和连接节点的边组成的结构，节点表示对象，边表示对象之间的关系。
最小生成树
evsqiezi
10-23 410
prim算法简单描述 1).输入：一个加权连通图，其中顶点集合为V，边集合为E； 2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空； 3).重复下列操作，直到Vnew = V： a.在集合E中选取权值最小的边，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之
C++算法集锦：图论
05-06 1654
图论最小生成树 最小生成树 牛客连接： 最小生成树 解法1 思路：kruskal算法+并查集 利用kruskal的思想，每次选择最短的路径，加入到候选集和中，从而最终连通整个图。 这里同时采用并查集的思想，每次将一条对一条候选路径进行选择的时候，判断两个端点是否拥有共同父亲，如果拥有则表明这两个点之间已经存在被加入候选集合中了，放弃这条边；如果没有拥有共同父亲，则将两个点连接，即指定一个点为另一个点的父亲，并且选择这条边加入连通图。最终，判断完所有的路径。 class Solution { publ
图论 C++语言实现.zip
03-16
可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。可下载学习借鉴，你会有所收获。 项目资源具有较高的学习借鉴价值，也可直接拿来修改复现。可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。可下载...
图论算法库 C++ 语言实现.zip_C++图论_C++图论的库_c++ 图论库_starfish_图论最优路径
07-14
图论算法库 C++ 语言实现 代码内容 图论算法库，包括以下算法： 单源最短路径 Dijkstra 算法 单源最短路径 Bellman-Ford 算法 最小生成树 Prim 算法 每对节点间最短路径 Flod-Warshall 算法 语言 C++ 编译...
图论基础_C++_学习_C++图论_图论方法c++_
10-02
综上所述，"图论基础_C++_学习_C++图论_图论方法c++_"的主题涵盖了图论的基本概念、C++中的图表示以及相关的算法实现。通过深入学习这部分内容，你将能够利用图论解决各种复杂的计算问题，并提升自己的编程能力。
图论算法(C++版).ppt
01-13
在C++中，实现图论算法通常涉及到数据结构的选择和特定的编程技巧。以下是关于图论及其C++实现的关键知识点： 1. **图的基本概念**： - **图的定义**：图由顶点（节点）和边组成，数学上表示为`graph=(V,E)`，其中...
图论基本算法c++实现
wangbyby
10-31 913
#include<iostream> #include<vector> #include<set> #include<map> #include<list> #include<float.h> #include <regex> #include <string> #include <fstream...
图论算法和C++实现
10-19
Dijkstra Floyd-Warshall Prim ...
图的C++实现
01-18
利用C++对图进行封装（图类），包括有向图和无向图，提供常用的对图的操作，如：获取图大小、添加节点、打印邻接矩阵、深度遍历和宽度遍历、最小生成树计算（Prim和Kruskal算法）等，并提供了简单的调用示例。
常用图论算法C++代码
01-03
包含最常用的图论算法的C++源代码，如，Dijkstra, floyd等最短路径算法，以及Max Flow, Minimum Cut,Minimum Coloring, Kruskal， Ford Fulkerson,等等算法。
Graph_cpp：C ++图论算法
02-15
C ++图论算法
c++图论
setprecisiona的博客
11-06 1570
图论
【算法】图论专题C++
nofish_的博客
03-21 836
聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。优先队列具有队列的所有特性，包括基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的。例如，编号为 2021 和 922 两个城邦之间，千位、百位和个位都不同，将这些数位上的数字加起来是 (2+0+1) + (0+9+2) = 14。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。
图论算法-C++语言实现
DanielSYC的博客
10-15 604
图的基本数据结构与算法
图论的C++实现
qq_43410173的博客
11-01 870
首先，我们先看一下什么是图，图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为G(V，E)，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 我们现在对图已经有一个基本的认识了以后，我们先来看一下相关的术语。 顶点(Vertex)：在图中的数据元素。 边：图中，任意两顶点之间都可能有关系，顶点之间的逻辑关系用边来表示。 无向边(Edge)：若顶点Vi到Vj之...
C++实现：图论求解第K短路
"这篇文章主要介绍了如何使用C++编程语言实现图论中的找第K短路问题。通过SPFA（Shortest Path Faster Algorithm）算法和A*（A-star）搜索算法来寻找图中从源节点到目标节点的第K条最短路径。" 在图论中，找第K短路...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yhaida

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值