离散实验3，中国邮递员问题，代码留档

原创 于 2024-01-03 23:29:59 发布 · 1k 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

本文讲述了如何使用深度优先搜索和Dijkstra算法解决邮递员问题，包括判断图是否为欧拉图，处理奇数顶点，构建最小权重的欧拉路径，以及通过最大匹配找到最短路径。

解决最大匹配问题简单，暴力的做法就是深搜，每一条边都搜一下，看看能不能搜，能搜的话就可以搜可以不搜，不能搜索就标定这边不能搜索然后接着往下走，然后找其中的最大的匹配即可。

  而邮递员问题，这里用的是无向简单图，所以简单得多，检查一下是不是欧拉图，若是欧拉图，欧拉图由Hierholzer 算法来求，即欧拉图是由若干个圈构成的，那么最小的子问题就是把一个点的所有的圈都走一遍，走的时候删掉此边，那么一定能将整个欧拉图走完，然后倒序存入路径，这条欧拉路径就出来了，

  若不是欧拉图就有说法了，由握手定理可以知道，存在偶数个奇数顶点，若是要回到原点，只能通过加重边的方式使得这个图变为欧拉图，不然不存在欧拉环游使得从起始点回到起始点，将其变成欧拉图之后用回欧拉图的方法即可，问题是怎么求最短的路径，当前的权是1（不影响），若要变为欧拉图，那么奇度顶点之间一定是有带权路径的，这样才能使得这俩点度数为偶数，若奇度顶点有k个，最少有k/2个路径，由于只需要求奇度顶点之间的路径并且使得其最小，我们可以把奇度顶点单独拿出来，若有路径的则有边，由于给出的图是连通的，那么一定有边，这样就会形成一个k阶完全图，而且为了求加的权最小，这些完全图中的边的值为最小带权路径的值，比如点1到点3有两条路径，那么一定要选最短的那条作为边，这样能确保之后走的权最小。

  求出完全图之后，由于需要带权最小，那么任务就变成了求此完全图的最大匹配的最小带权组合，即存在若干个最大匹配，找权最小的那个，到这已经差不多了，然后将对应的路径加回原来的图中即可，这样得到的一定是欧拉图

参考代码如下：

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

//寻找所有的匹配
void dfs(int u,int n, int m, int grid[][1000], bool edgest[], bool pointst[], vector<vector<int>>& ans, vector<int>& setsize)
{
	if (u>m)
	{
		vector<int>path;//将搜索到的边存进去
		for (int i = 0; i < m; i++)
		{
			if (edgest[i])path.push_back(i);
		}
		setsize.push_back(path.size());
		ans.push_back(path);
		return;//深度搜索完毕,搜完边就行
	}
	int temp = 0;//临时用来计算此边关联的点有没有被搜索过
	int edge[2] = { 0 };//用来看是哪两个点
	for (int i = 0; i < n; i++)
	{
		if (grid[i][u]&&!pointst[i])
		{
			temp++;
			if (temp == 1)edge[0] = i;
			else edge[1] = i;
		}
	}
	if (temp == 2)//说明这条边能用
	{
		edgest[u] = true;
		pointst[edge[0]] = true;
		pointst[edge[1]] = true;
		dfs(u + 1, n, m, grid, edgest, pointst, ans, setsize);
		edgest[u] = false;
		pointst[edge[0]] = false;
		pointst[edge[1]] = false;
		dfs(u + 1, n, m, grid, edgest, pointst,ans, setsize);
	}
	else
	{   //这边不能用也能搜，但没有上面那么多，因为不用改变状态
		dfs(u + 1, n, m, grid, edgest, pointst, ans, setsize);
	}
}


void pathdfs(int x,int graph[][100],int n,vector<int>&ans) 
{
	for (int y = 0; y < n; ++y) 
	{
		if (graph[x][y] > 0) 
		{
			graph[x][y]--;
			graph[y][x]--;
			pathdfs(y,graph,n,ans);
		}
	}
	ans.push_back(x);
}



// 构造最短路径
void ConstructPath(const vector<int>& precursor, int start, int end, vector<int>& path) 
{
	path.clear();
	int curr = end;
	while (curr != start) 
	{ // 从终点回溯到起点
		path.push_back(curr);
		curr = precursor[curr];
	}
	path.push_back(start);

	reverse(path.begin(), path.end()); // 反转路径，使其从起点到终点
}

// Dijkstra算法实现
void Dijkstra(int start, vector<int>& distance, vector<int>& precursor, vector<vector<int>> adjacencyMatrix) 
{
	// 定义无穷大的距离值
	const int INF = INT_MAX;
	int n = adjacencyMatrix.size();
	distance.resize(n, INF); // 初始化距离数组为无穷大
	distance[start] = 0; // 起点到自身的距离为0
	precursor.resize(n, -1); // 初始化前驱节点数组，表示还未访问的节点前驱为-1

	priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; // 小顶堆存储未访问节点
	pq.push(make_pair(0, start)); // 将起点加入小顶堆

	while (!pq.empty()) {
		int dist = pq.top().first;
		int currNode = pq.top().second;
		pq.pop();

		// 如果当前节点已经被访问过，跳过
		if (dist > distance[currNode]) {
			continue;
		}

		// 遍历当前节点的相邻节点
		for (int i = 0; i < n; ++i) 
		{
			if (adjacencyMatrix[currNode][i] != INF) 
			{ // 判断当前节点与相邻节点是否存在连接
				int newDistance = dist + adjacencyMatrix[currNode][i];
				if (newDistance < distance[i]) 
				{ // 如果新的距离更小
					distance[i] = newDistance;
					precursor[i] = currNode; // 更新前驱节点
					pq.push(make_pair(newDistance, i));
				}
			}
		}
	}
}

void postman(int n,int m,int grid[][1000])
{
	//分三种情况，欧拉图，半欧拉图，非欧拉图
	bool flag1 = false, flag2 = false, flag3 = false;//与上面情况对应
	vector<int> path;//存放每个点度数
	for (int i = 0; i < n; i++)
	{
		int sum = 0;
		for (int j = 0; j < m; j++)
		{
			if (grid[i][j])
				sum++;
		}
		path.push_back(sum);
	}
	int odd=0;//记录有多少个奇数顶点,同时存下奇数度顶点
	vector<int> oddnum;
	for (int i = 0; i < n; i++)
		if (path[i] % 2 == 1)
		{
			odd++;
			oddnum.push_back(i);
		}
	vector<int>result;//存放结果
	//若odd为0则代表其为欧拉图,所有的度数均为偶数
	//将关联矩阵转化为邻接矩阵和边矩阵
	int graph[50][100] = { 0 }, ed[50][100] = { 0 };
	for (int j = 0; j < m; j++)
	{
		vector<int>arr;
		for (int i = 0; i < n; i++)
		{
			if (grid[i][j])arr.push_back(i);
		}
		int L = arr[0], r = arr[1];
		graph[L][r] = 1;
		graph[r][L] = 1;
		ed[L][r] = j;
		ed[r][L] = j;
	}

	if (odd != 0)
	{
		int dfsgridst[100] = { 0 };
		for (int i=0; i < path.size(); i++)dfsgridst[path[i]] = i;
		int oddgrid[100][100] = {0};//存奇数顶点的对应的最短路的矩阵
		vector<vector<vector<int>>>oddpath(odd, vector<vector<int>>(odd));
		// 定义无穷大的距离值
		const int INF = INT_MAX;
		vector<vector<int>> adjacencyMatrix(n, vector<int>(n, INF));
		vector<int> ans;
		//用adjacencyMatrix存邻接矩阵
		for (int j = 0; j < m; j++)
		{
			vector<int>arr;
			for (int i = 0; i < n; i++)
			{
				//若不能直接到达那么距离是无穷
				if (grid[i][j])arr.push_back(i);
			}
			int L = arr[0], r = arr[1];
			adjacencyMatrix[L][r] = 1;
			adjacencyMatrix[r][L] = 1;
		}
		for (int i = 0; i < n; i++)adjacencyMatrix[i][i] = 0;

		for (int i = 0; i < odd; i++)
		{
			int start = oddnum[i]; // 起点
			vector<int> distance; // 保存最短距离的数组
			vector<int> precursor; // 保存前驱节点的数组
			
			Dijkstra(start, distance, precursor, adjacencyMatrix);
			for (int k = 0; k < distance.size(); k++)//distance里面存起点到第k个点的最短距离
			{
				for (int z = 0; z < odd; z++)
				{
					if (oddnum[z] == k)
					{
						oddgrid[i][z] = distance[k];
					}
				}
			}
			for (int j = 0; j < odd; j++)
			{
				if (i == j)
				{
					oddpath[i][j].push_back(0);
					continue;
				}
				vector<int> path; // 保存最短路径的数组
				int end = oddnum[j]; // 终点
				ConstructPath(precursor, start, end, path);	
				for (auto x : path)//存好路径
				{
					oddpath[i][j].push_back(x);
				}
			}		
		}

		vector<vector<int>>ansdfs;
		vector<int>setsize;
		bool edgest[100] = { false }, pointst[100] = { false };
		//将oddnum转化为关联矩阵,有n*（n-1）/2条边
		int dfsgrid[20][1000] = { 0 };
		int eddfs[100][100] = {0};
		for (int i = 0; i < odd; i++)
			for (int j = 0; j < odd; j++)eddfs[i][j] = -1;
		int idx = 0;
		for (int p = 0; p < odd; p++)
		{
			for (int z = p+1; z < odd; z++)
			{
				if (oddgrid[p][z])//若有边就将其存入关联矩阵当中
				{
					dfsgrid[p][idx] = 1;
					dfsgrid[z][idx] = 1;
					eddfs[p][z] = idx;
					eddfs[z][p] = idx;
					idx++;
				}
			}
		}
		dfs(0, odd, idx, dfsgrid, edgest, pointst, ansdfs, setsize);
		int len = ansdfs.size();
		int max = 0;//记录最大匹配的位置;
		for (int i = 0; i < len; i++)
		{
			if (setsize[i] > max)
				max = i;
		}
		int reslong = ansdfs[max].size();//记录找到的数组的长度
		//将所有的最大匹配集输出
		int mindfs = INF;
		int flagdfs = 0;
		for (int k = 0; k < len; k++)
		{
			if (setsize[k] == reslong)//若是最大匹配集的长度就将对应的路径加到矩阵当中
			{	
				int sum = 0;
				for (int i = 0; i < reslong; i++)
				{
					for (int edi = 0; edi < odd; edi++)
					{
						for (int edj = edi + 1; edj < odd; edj++)
						{
							if (ansdfs[k][i] == eddfs[edi][edj])
							{
								sum += oddpath[edi][edj].size()-1;
							}
						}
					}
				}
				if (sum < mindfs)
				{
					mindfs = sum;
					flagdfs = k;
				}
			}
		}
		vector<vector<int>>finalans;
		for (int i = 0; i < reslong; i++)
		{
			for (int edi = 0; edi < odd; edi++)
			{
				for (int edj = edi + 1; edj < odd; edj++)
				{
					if (ansdfs[flagdfs][i] == eddfs[edi][edj])
					{
						finalans.push_back(oddpath[edi][edj]);
					}
				}
			}
		}
		for (int i = 0; i < finalans.size(); i++)
		{
			for (int j = 0; j < finalans[i].size()-1; j++)
			{
				int Le = finalans[i][j], ri = finalans[i][j + 1];
				graph[Le][ri] += 1;
				graph[ri][Le] += 1;
			}
		}
	}
		vector<int> ans;
		pathdfs(0, graph, n,ans);
		int needlen = ans.size();
		vector<int> turned;
		printf("\n路径为{");
		for (int i = 0; i < needlen-1; i++)
		{
			printf("e%d", ed[ans[i]][ans[i + 1]]+1);
		}
		printf("}");

}

int main()
{
	int grid[100][1000] = { 0 };
	int n, m;

	vector<vector<int>>ans;
	vector<int>setsize;
	bool edgest[100] = { false }, pointst[100] = { false };
	cin >> n >> m;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
			cin >> grid[i][j];
	}
	dfs(0, n, m, grid, edgest, pointst, ans, setsize);
	int len = ans.size();

	int max = 0;//记录最大匹配的位置;
	for (int i = 0; i < len; i++)
	{
		if (setsize[i] > max)
			max = i;
	}
	int reslong = ans[max].size();//记录找到的数组的长度
	//将所有的最大匹配集输出
	for (int k = 0; k < len; k++)
	{
		if (setsize[k] == reslong)//若是最大匹配集的长度就输出
		{
			printf("最大匹配集为:{");
			for (int i = 0; i < reslong; i++)
			{
				printf("e%d,", ans[k][i]);
			}
			printf("\b}\n");
		}
		
	}
	
	postman(n,m,grid);


    return 0;
}
//中国邮递员问题
//5 6
//1 0 0 1 0 1
//1 1 0 0 0 0
//0 1 1 0 0 0
//0 0 0 1 1 0
//0 0 1 0 1 1

【2024美赛】解密背后的算法：2024美赛优化模型揭秘
Fanjufei的博客
09-11 1679
目录1、逐步回归算法2、对比MATLAB与lingo求解线性规划实例3、最优化计算蒙特卡洛法4、装配线平衡模型5、最短路问题6、线性规划求解7、求解二次规划问题8、非线性规划问题9、无约束最优化问题10、分配问题模型11、指派问题的计算机求解（实例）12、最短路问题 之 固定起点的最短路13、行遍性问题 — 中国邮递员问题14、每对顶点之间的最短路算法15、消防车调度问题模型16、面试顺序模型17、图论与TSP模型结合18、推销员问题模型19、离散系统模拟实例: 排队问题（排队论）20、在交通网络中设计算法
离散数学实验----中国邮递员问题
ajajajsj的博客
11-16 6527
离散数学实验 中国邮递员问题
中国邮递员问题matlab
10-31
中国邮递员问题matlab的程序代码，并画出最终图形
chinese-postman-problem:中国邮递员问题的C ++解决方案
05-09
中国邮递员问题的C ++解决方案 克隆存储库及其依赖项（子模块）： git clone --recursive https://github.com/dilsonpereira/chinese-postman-problem 在Linux上编译： make chinese 用法： ./chinese -f <inputFile> 文件格式： 前两行给出n（顶点数）和m（边数）。 接下来的m行中的每行都有一个表示边的元组（u，v，c），其中u和v是边的端点（基于0的索引），而c是其成本。 输入样例： 10 15 0 1 1 0 4 3 1 2 0 1 4 10 2 3 9 2 5 2 2 6 7 3 6 3 4 5 4 4 7 2 5 7 6 6 8 4 6 9 2 7 8 1 8 9 5 样本输出： Solution cost: 62 Solution: 0 4 7 8 9
中国邮递员问题+代码实现（cpp）
qq_29592167的博客
05-16 1万+
中国邮递员问题是一个和旅行商问题比较相关但又不太相同的一个问题，而且个人感觉理解的难度更大一点，当然，这就是仁者见仁，智者见智了，旅行商问题是不能回头的，一个节点访问过了不能回来了，并不需要走完所有的路，但是中国邮递员问题可以多次访问一个节点，因为中国邮递员问题要求的是要访问所有的街道，即，每条街道必须访问到。在这样的前提下，如果规划路径使得返回邮局时路程最短。 试想...
HITOJ 2739 The Chinese Postman Problem（有向带权图上的中国邮递员问题）
yasolx的博客
09-05 5238
The Chinese Postman Problem Source : bin3 Time limit : 1 sec Memory limit : 64 M Submitted : 530, Accepted : 177 A Chinese postman is assigned to a small town in China to deliver letters. In t
【图论】中国邮递员问题、平面图上最大割问题的多项式时间算法
qaqwqaqwq的博客
04-05 9396
本文介绍了中国邮递员问题的Edmonds-Johnson算法、平面图上最大割问题的多项式时间算法和顶点图（apex graph）上最大割问题的NP完全性。
c++代码解决文件中的问题
最新发布
12-22
为了帮助你编写C++代码来解决《离散数学Ⅱ》实验3中的问题，我们可以将其分为两个主要部分： 1. **图的最大匹配** 2. **中国邮递员问题** ### 1. 图的最大匹配 #### 代码实现 ```cpp #include #include #...
玩转NLP论文实战图书馆----附论文地址和代码地址
Axiaotangshuju的博客
03-04 2194
一、文本生成概述 1、文本生成概述： https://www.jiqizhixin.com/articles/2017-05-22 任务包括：对话生成、摘要生成、机器翻译。 2、NLP综述：自然语言生成-NLG： https://zhuanlan.zhihu.com/p/85363175 3、清华NLP组年度巨献：机器翻译30年最重要论文阅读清单： https://blog.youkuaiyun.com/qq_27009517/article/details/86566987 二、评价指标： 1、文本生成1
使用tarjan算法和fleury算法求解中国邮递员问题
m0_62548870的博客
11-13 838
本文章是根据本人大一的实训内容的感悟所写出来的，有不足的还请大家指针才是。
matlab邮递员问题
05-02
matlab邮递员问题 很好用试了一下 感觉挺好 试试看
中国邮路问题c语言代码
12-03
实现n<15的最短遍历 Gord is training for a marathon. Behind his house is a park with a large network of jogging trails connecting water stations. Gord wants to find the shortest jogging route that travels along every trail at least once. Input Input consists of several test cases. The first line of input for each case contains two positive integers: n <= 15, the number of water stations, and m < 1000, the number of trails. For each trail, there is one subsequent line of input containing three positive integers: the first two, between 1 and n, indicating the water stations at the end points of the trail; the third indicates the length of the trail, in cubits. There may be more than one trail between any two stations; each different trail is given only once in the input; each trail can be travelled in either direction. It is possible to reach any trail from any other trail by visiting a sequence of water stations connected by trails. Gord&#39;s route may start at any water station, and must end at the same station. A single line containing 0 follows the last test case. Output
邮递员问题matlab代码-traffinjam:供个人使用和实验的Algotrading项目
06-16
邮递员问题matlab代码果酱 供个人使用和实验的 Algotrading 项目 使用平台羊驼 是一个很好的测试算法交易程序的平台，您可以通过注册免费测试自己的结果。 很棒，但是以下资源提供了额外的有用信息： 用于羊驼交易 API 对于使用 Postman 的 Alpaca API ，一位出色的 youtuber，通过他的和 社区中使用的更多平台 是一个汇集来自不同公司和服务的数据的平台，并得到 R、MATLAB、Ruby 等编程语言的支持。 但是，某些数据集必须付费 或者 。 这里的一个问题是雅虎金融 API 只能接收 get 命令（免费版本，非常适合自己的计算和模拟，但不适用于真实交易） 谷歌金融 API ，然而它主要不是通过代码使用，而是通过谷歌表格使用（有关详细信息，请参阅文档）。 Algotrading101 提供了额外的见解。 Alpha Vantage在 RapidAPI 文档中具有每分钟 5 个请求的速率限制和最大 500 个请求/天的硬性限制。 Trading View（需要 Pine Script）是 Google Finance API 的替代方案。 非常适合学习
邮递员问题matlab代码-2R_Drawing_Robot:绘制人类图像轮廓的2R操纵器的所有代码。它是实现的计算机视觉代码和Matlab的
06-16
邮递员问题matlab代码2R_Drawing_Robot 绘制人类图像轮廓的 2R 操纵器的所有代码。 它是实现的计算机视觉代码和 Matlab 的混合，部分来自 Petr Zikovsky。 还有一些python代码，基本上用蒙特卡罗定位和遗传算法解决了农村邮递员问题。 这些代码来自各种在线资源的组合，不幸的是我现在找不到。 如果有任何疑问，请给我留言/邮件
中国邮递员问题的深入剖析与算法实现(附例题及MATLAB、LINGO代码)
热门推荐
weixin_42633850的博客
03-26 3万+
中国邮递员问题的深入解读一、研究背景1.1 哥尼斯堡七桥问题1.2 欧拉图1.3 中国邮递员问题二、中国邮递员问题深入解读2.1 图论语言描述2.2 奇偶点图上作业法^[1]如何插入一段漂亮的代码片2.3 最小二分匹配法1)针对无向图2)针对有向图2.4 $fleury$算法设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特...
【梳理】离散数学 第15章 欧拉图与哈密顿图 15.3 最短路问题、中国邮递员问题与货郎担问题
COFACTOR
11-16 4208
教材：《离散数学》第2版 屈婉玲 耿素云 张立昂 高等教育出版社 源文档高清截图在最后 15.3 最短路问题、中国邮递员问题与货郎担问题 1、设图G(V, E)，给定W：E→R，对G的每一条边e，称W(e)为边e的权，把这样的图G称为带权图，记为G(V, E, W)或G = <V, E, W>或G = (V, E, W)。当e = (u, v)（或<u, v>）时，也可以把...
matlab中邮递员问题实例,中国邮递员问题matlab
weixin_35041472的博客
03-22 2297
中国邮递员问题的EXCEL求... 1页 免费 对中国邮递员问题的数理... 4页 1下载券 中国邮递员问题matlab 6页 1下载券 喜欢...中国邮递员问题摘要:欧拉图起源于哥尼斯堡七桥问题,通过图中所有边一次且仅一次行遍...中国邮递员问题 (Chinese Postman Problem) 主要内容 七桥问题与一笔画 中国邮递员问题 欧拉图及求欧拉回路的算法 求解中国邮递员问题的...
【优化模型】行遍性问题 — 中国邮递员问题
Fanjufei的博客
04-14 1456
1、欧拉图 2、中国邮递员问题定义 邮递员发送邮件时，要从邮局出发，经过他投递范围内的每条街道至少一次，然后返回邮局，但邮递员希望选择一条行程最短的路线．这就是中国邮递员问题. 若将投递区的街道用边表示，街道的长度用边权表示，邮局街道交叉口用点表示，则一个投递区构成一个赋权连通无向图．中国邮递员问题转化为：在一个非负加权连通图中，寻求一个权最小的巡回．这样的巡回称为最佳巡回． 3、中国邮递员问题-算法 G是欧拉图 此时G的任何一个欧拉巡回便是最佳巡..
探索离散数学实验：TSP问题的两种算法近似解比较
此外，报告文档（离散数学实验电子报告.docx）和实验说明（离散数学I实验说明.pptx）是学生在实验过程中的重要参考文档，它们包含了实验的目的、步骤、理论背景和可能遇到的问题的解决方案。通过对这些文档的仔细...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值