devbox
爱喝兽奶帝天荒
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

离散数学实验----中国邮递员问题_离散数学 送货员问题

作者：爱喝兽奶帝天荒 | 2024-07-04 00:54:00

赞

踩

离散数学 送货员问题

  1. 实验目的和要求
    1. 实验目的：
  1. 理解什么是欧拉图，熟悉欧拉路和欧拉回路的概念。
  2. 掌握Dijkstra算法，求解最短路径
  3. 掌握Fleury算法，求解欧拉回路。
  4. 了解Edmonds-Johnson算法解决中国邮递员问题的基本思路。
  5. 通过程序实现中国邮递员问题，强化其基本思想和实际应用。

    1. 实验要求：
  2. 针对下图所示加权图G，给出中国邮递员问题的解决方案。
  3. 用流程图简述解决中国邮递员问题的流程。
  4. 对核心算法（如Dijkstra算法、Fleury算法）进行编程实现。
  5. 分析实验结果，验证其正确性。
  6. 总结实验，撰写实验心得。

图G

  1. 实验环境和工具
    1. 编程语言：

    C++

    1. 编程环境（编译器）：

Visual Studio 2019

  1. 实验结果
    1. 算法流程图

解题思路：

  1. 求出图G中奇数度顶点集合
  2. 若奇数度顶点个数为0<=>图G为欧拉图，直接使用Fleury算法求出欧拉回路，即最优邮路。
  3. 若奇数度顶点个数为2n（n=1，2，3......）<=>图G不是欧拉图，需添加一些重边。
  4. 用Dijkstra算法求出奇数度顶点两两之间的最短距离。
  5. 将奇数度顶点两两分组，遍历所有组合情况，根据已经求出的最短距离，找出最短的组合方式，即最优分组。
  6. 根据最优分组情况为图G添加重复边。
  7. 对添加重复边之后得到的图G’利用Fleury算法，求出欧拉回路，即此时的最优邮路。

流程图：

整体算法流程图

Fleury算法流程图

  1. 程序核心代码
  1.  
  2. 判断是否为连通图：
  3.  
  4. bool ConnectivityTest(int start, bool& bNoPoints){
  5.  
  6. set<int> nodeSet; // 连通顶点集
  7.  
  8. vector<int> test_nodes; // 与新加入连通点连通的未加入点集
  9.  
  10. set<int> singlePoints; // 图中的单点集
  11.  
  12. int i, j;
  13.  
  14. // 先找出单点
  15.  
  16. bool hasEdge = false;
  17.  
  18. for (i = 0; i < V; i++){
  19.  
  20. hasEdge = false;
  21.  
  22. // 这里起始应该是0，不然最后一个点如果是单点则无法判断
  23.  
  24. for (j = 0; j < V; j++) {
  25.  
  26. if (Graph[i][j] > 0){
  27.  
  28. hasEdge = true;
  29.  
  30. break;
  31.  
  32. }
  33.  
  34. }
  35.  
  36. if (!hasEdge){
  37.  
  38. singlePoints.insert(i);
  39.  
  40. }
  41.  
  42. }
  43.  
  44. // 设置bNoPoints标志
  45.  
  46. bNoPoints = (singlePoints.size() == V);
  47.  
  48. // start点必须在连通图中
  49.  
  50. if (singlePoints.find(start) != singlePoints.end()) {
  51.  
  52. return false;
  53.  
  54. }
  55.  
  56. test_nodes.push_back(start);
  57.  
  58.  
  59.  
  60. while (test_nodes.size() > 0){
  61.  
  62. int testNode = test_nodes.back();
  63.  
  64. test_nodes.pop_back();
  65.  
  66. for (i = 0; i < V; i++){
  67.  
  68. if (Graph[testNode][i] > 0){
  69.  
  70. if (nodeSet.insert(i).second){
  71.  
  72. test_nodes.push_back(i);
  73.  
  74. }
  75.  
  76. }
  77.  
  78. }
  79.  
  80. }
  81.  
  82.  
  83.  
  84. for (i = 0; i < V; i++){
  85.  
  86. // 存在点既不是单点，也不在当前连通顶点集中，则这个点一定在其他连通子图中，返回假
  87.  
  88. if (singlePoints.find(i) == singlePoints.end()&& nodeSet.find(i) == nodeSet.end()){
  89.  
  90. return false;
  91.  
  92. }
  93.  
  94. }
  95.  
  96. return true;
  97.  
  98. }
  99.  
  100.  
  101.  
  102. Dijkstra算法求最短距离
  103.  
  104. int Dijstra(int v0, int v1, bool useCache){
  105.  
  106. // 之前计算过了，直接返回值
  107.  
  108. if (useCache && Cache[v0][v1] != 0) {
  109.  
  110. return Cache[v0][v1];
  111.  
  112. }
  113.  
  114. int i, s, w, min, minIndex;
  115.  
  116. bool Visited[MAX_NODE];//判断顶点是否被访问过
  117.  
  118. // 初始化最短路径长度数据，所有数据都不是最终数据
  119.  
  120. for (s = 0; s < V; s++){
  121.  
  122. Visited[s] = false;
  123.  
  124. Dist[s] = COST_NO_LINK; // 初始最大距离
  125.  
  126. }
  127.  
  128. // 首先选v0到v0的距离一定最短，最终数据
  129.  
  130. Visited[v0] = true;
  131.  
  132. Dist[v0] = 0;
  133.  
  134. s = v0; // 0 预先选中v0点
  135.  
  136. for (i = 0; i < V; i++){
  137.  
  138. //更新该点到其他未选中点的最短路径
  139.  
  140. for (w = 0; w < V; w++){
  141.  
  142. if (!Visited[w] && Cost[s][w] < COST_NO_LINK&& Dist[w] > Dist[s] + Cost[s][w]){
  143.  
  144. Dist[w] = Dist[s] + Cost[s][w];
  145.  
  146. }
  147.  
  148. }
  149.  
  150. //如果在中间过程找到了目标点v1，则不再继续计算了
  151.  
  152. if (s == v1){
  153.  
  154. Cache[v0][v1] = Dist[s];
  155.  
  156. Cache[v1][v0] = Dist[s];
  157.  
  158. return Dist[s];
  159.  
  160. }
  161.  
  162. //选中相应点
  163.  
  164. min = COST_NO_LINK;
  165.  
  166. for (w = 0; w < V; w++){
  167.  
  168. if (!Visited[w] && Dist[w] < min){
  169.  
  170. minIndex = w;
  171.  
  172. min = Dist[w];
  173.  
  174. }
  175.  
  176. }
  177.  
  178. s = minIndex;
  179.  
  180. Visited[s] = true;
  181.  
  182. }
  183.  
  184. }
  185.  
  186.  
  187.  
  188. 找出最优分组
  189.  
  190. bool Grouping(int level){
  191.  
  192. int i, j, findI = -1;
  193.  
  194. for (i = 0; i < V; i++){
  195.  
  196. if (Odd_Group[i] == 1){
  197.  
  198. Odd_Group[i] = level; // 找到第一个组合点。
  199.  
  200. findI = i;
  201.  
  202. break;
  203.  
  204. }
  205.  
  206. }
  207.  
  208. bool re = true;
  209.  
  210. // 这里是形成一对新的组合后的地方，此时应该计算各组合最小路径之和。
  211.  
  212. if (findI == -1)  {
  213.  
  214. int weightSum = 0;
  215.  
  216. // 根据level的值可以知道分组的取值是从2到level-1的，所以i如是计数
  217.  
  218. for (i = 2; i < level; i++) {
  219.  
  220. int index[2];
  221.  
  222. int* pIndex = index;
  223.  
  224. for (j = 0; j < V; j++){
  225.  
  226. if (Odd_Group[j] == i){
  227.  
  228. *pIndex = j;
  229.  
  230. // 设置了第二个index值
  231.  
  232. if (pIndex == index + 1) {
  233.  
  234. break;
  235.  
  236. }
  237.  
  238. pIndex++;
  239.  
  240. }
  241.  
  242. }
  243.  
  244. weightSum += Dijstra(index[0], index[1], true); // 这里暂时只计算最短路权值和，不实际上添加边，最后才添加。这样加边计算只会调用一次。
  245.  
  246. }
  247.  
  248. // 当前组合比以往要优，将当前的排列组合情况更新到全局
  249.  
  250. if (weightSum < Shortest_Path_Weight) {
  251.  
  252. Best_Grouping(); // 如果当前分组比以往都好，备份一下
  253.  
  254. Shortest_Path_Weight = weightSum;
  255.  
  256. return true; // 找到了更优组合，返回递归调用为真
  257.  
  258. }
  259.  
  260. else{
  261.  
  262. return false; // 没找到了更优组合，返回递归调用为假
  263.  
  264. }
  265.  
  266. }
  267.  
  268. else if (findI > -1){
  269.  
  270. // 上面找到了第一个点了，现在从上面继续找第二个点。
  271.  
  272. for (/* 继续上面的for */; i < V; i++){
  273.  
  274. // 找到第二个点
  275.  
  276. if (Odd_Group[i] == 1) {
  277.  
  278. Odd_Group[i] = level;
  279.  
  280. re = Grouping(level + 1);
  281.  
  282. Odd_Group[i] = 1; // 无论当前分组是不是当前最好分组，我们都还要继续查找剩余分组情况
  283.  
  284. }
  285.  
  286. }
  287.  
  288. }
  289.  
  290. else{
  291.  
  292. cerr << "findCount值异常" << endl;
  293.  
  294. exit(-1);
  295.  
  296. }
  297.  
  298.  
  299.  
  300. if (findI > -1){
  301.  
  302. Odd_Group[findI] = 1; // 无论当前分组是不是最好分组，我们都还要继续查找剩余分组情况
  303.  
  304. }
  305.  
  306.  
  307.  
  308. return re;
  309.  
  310. }
  311.  
  312.  
  313.  
  314. Fleury算法求欧拉回路
  315.  
  316. void Fleury(int start) {
  317.  
  318. int i;
  319.  
  320. int vi = start; // v0e1v1…eivi已经选定
  321.  
  322. bool bNoPoints, bCnecTest;
  323.  
  324. cout << "你要的结果：";
  325.  
  326. while (true) {
  327.  
  328. // 找一条不是割边的边ei+1
  329.  
  330. for (i = 0; i < V; i++) {
  331.  
  332. if (Graph[vi][i] > 0) {
  333.  
  334. // 假设选定（vi，i）这条边
  335.  
  336. Graph[vi][i]--; // 这里会破坏全局Graph的值，但暂时没影响了，都不用了。
  337.  
  338. Graph[i][vi]--;
  339.  
  340. bCnecTest = ConnectivityTest(i, bNoPoints);
  341.  
  342. if (!bNoPoints && !bCnecTest) {
  343.  
  344. Graph[vi][i]++;
  345.  
  346. Graph[i][vi]++;
  347.  
  348. continue;
  349.  
  350. }
  351.  
  352. // 选定（vi，i）这条边
  353.  
  354. cout << (char)('a' + vi) << "->" << (char)('a' + i) << " ";
  355.  
  356. sumWeight += Cost[vi][i];
  357.  
  358. vi = i;
  359.  
  360. break;
  361.  
  362. }
  363.  
  364. }
  365.  
  366. if (i == V) {
  367.  
  368. cout << endl;
  369.  
  370. break; // 到这里边找完了
  371.  
  372. }
  373.  
  374. }
  375.  
  376. }
  377.

    1. 运行结果

程序运行结构图

    1. 运行结果分析

假设权重为4的边长度为4个单位长度，其余以此类推。

由上述运行结果可得出图G的最短邮路长度为104个单位长度。

添加的重复边有5条：

  1. -b  2   a--e  5  c--d  5

d--h  4   j--k  3

添加重复边的总权重为19。

为了验证结果的正确性（也就是所添加重复边的正确性），我采用书本第239页上给出的定义来推导。

  1. 首先添加重边去除奇数度顶点。

图1

  1. 删除偶数条重边。

图2

  1. 调整回路中的权重问题，调整单边和重边。
  1. 重复边集E的长度之和不超过这个圈的长度的一半
  2. 图中没有二重以上的边

依据以上两点要求对图进行调整：

图3

图4

图5

可以发现图5已经满足了最优的两点条件，因此图5就是我们需要构造的欧拉图。

从图中可以得到最优情况添加的重复边为：

  1. -b  2   a--e  5  c--d  5

d--h  4   j--k  3

添加重复边的总权重是19。

图5的最优邮路的长度为104个单位长度。

        此结果与我实验得到的结果是完全一致的，一次这次实验的答案是准确无误的。

  1. 实验心得

本次实验，我结合老师上课所教的内容与自己课后在网上学习到的中国邮递员问题的相关内容以及算法，完成了此次实验，通过程序实现了中国邮递员问题，同时也强化了我对于中国邮递员问题基本思想的理解与实际应用的能力。

通过此次实验，让我加深了对于欧拉图的理解，熟悉了欧拉路和欧拉回路的基本概念，掌握了使用Dijkstra算法求解最短路径的方法，学习了使用Fleury算法求解欧拉回路的方法，同时我也学习并且了解了Edmonds-Johnson算法解决中国邮递员问题的基本思路。

此次实验，我解决中国邮递员问题的主要思路是Edmonds-Johnson算法的思路，但是我对其中的一些步骤进行了调整，Edmonds-Johnson算法在求解完最短路径之后是利用求解完全图，然后再在完全图中找出权值最小的完备匹配。我在这次实验中采用的是将奇数度顶点两两分组，遍历所有组合情况，根据已经求出的最短距离，找出最短的组合方式，即最优分组。根据最优分组情况为图G添加重复边。最后对添加重复边之后得到的图G’利用Fleury算法，求出欧拉回路，即此时的最优邮路。

经过本次实验我深刻的体会到中国邮递员算法是一个十分有意义的算法，它可以解决我们实际生活中的问题，通过这次实验对中国邮递员问题的解决，让我学习到了什么是中国邮递员算法，也让我学习了如何编程解决这个问题，求解出最后的最优邮路。还让我在课本上学习到的欧拉图等内容得到了巩固，并运用到了实际的算法问题之中。

在实验中我也遇到了许多的问题，就比如有的算法思路虽然简单，但是实现起来还是需要琢磨许久，并且还需要在网上或者课本上找寻相关的内容才能最后将其完成，虽然解决问题的过程是艰辛的，是需要花费时间的，但是我认为这是值得的，最后解决了问题之后也会让我觉得无比的喜悦。

最后我想说，这次实验带给我的收获是巨大的，不仅使我编写代码的能力得到了提升，同时也让我学习到了许多有用的算法，使我的知识得到了丰富。因此，在我看来这次实验对于我而言是十分有意义的。

  1. 源代码
  1. #include <iostream>
  2.  
  3. #include <cstdlib>//包含多种宏和常数值
  4.  
  5. #include <set>
  6.  
  7. #include <vector>
  8.  
  9. #define MAX_NODE 100//最大结点数
  10.  
  11. #define COST_NO_LINK INT_MAX//顶点之间没有连接的权值
  12.  
  13. using namespace std;
  14.  
  15.  
  16.  
  17. int Graph[MAX_NODE][MAX_NODE];//图
  18.  
  19. int Cost[MAX_NODE][MAX_NODE];//权重
  20.  
  21. int V, E, SP;//顶点数，边数，起始点
  22.  
  23. int Odd_Group[MAX_NODE];//图的奇偶顶点情况
  24.  
  25. int Best_Group[MAX_NODE];//保存当前最优分组策略
  26.  
  27. int Shortest_Path_Weight(COST_NO_LINK);//添加边的最小权值
  28.  
  29. int Dist[MAX_NODE];//求从v0到v1最短路径结果，里面包含v0到最短路径上各点的最短权值
  30.  
  31. int Cache[MAX_NODE][MAX_NODE];//记录已经求过的最短路径值
  32.  
  33. int sumWeight = 0;//记录最短路径长度
  34.  
  35.  
  36.  
  37. //输入图的信息
  38.  
  39. void Input() {
  40.  
  41. int i, j;
  42.  
  43. int m, n;
  44.  
  45. char cs, cm, cn;
  46.  
  47. int w;
  48.  
  49. cout << "输入图的顶点数：";
  50.  
  51. cin >> V;
  52.  
  53. cout << "输入图边的数目：";
  54.  
  55. cin >> E;
  56.  
  57. cout << "输入起点：";
  58.  
  59. cin >> cs;
  60.  
  61. SP = cs - 'a';
  62.  
  63. for (i = 0; i < V; i++)
  64.  
  65. {
  66.  
  67. for (j = 0; j < V; j++)
  68.  
  69. {
  70.  
  71. Graph[i][j] = 0;
  72.  
  73. Cache[i][j] = 0;
  74.  
  75. Cost[i][j] = COST_NO_LINK;
  76.  
  77. }
  78.  
  79. Cost[i][i] = 0; // 置自己到自己为0
  80.  
  81. }
  82.  
  83. cout << "输入" << E << "条边对应的顶点和权值（顶点从a开始编号）：" << endl;
  84.  
  85. for (i = 0; i < E; i++)
  86.  
  87. {
  88.  
  89. cin >> cm >> cn >> w;
  90.  
  91. m = cm - 'a';
  92.  
  93. n = cn - 'a';
  94.  
  95. Graph[m][n] += 1;
  96.  
  97. Graph[n][m] += 1;
  98.  
  99. Cost[m][n] = w;
  100.  
  101. Cost[n][m] = w;
  102.  
  103. }
  104.  
  105. }
  106.  
  107.  
  108.  
  109. //Dijstra算法求最短距离
  110.  
  111. int Dijstra(int v0, int v1, bool useCache){
  112.  
  113. // 之前计算过了，直接返回值
  114.  
  115. if (useCache && Cache[v0][v1] != 0) {
  116.  
  117. return Cache[v0][v1];
  118.  
  119. }
  120.  
  121. int i, s, w, min, minIndex;
  122.  
  123. bool Visited[MAX_NODE];//判断顶点是否被访问过
  124.  
  125. // 初始化最短路径长度数据，所有数据都不是最终数据
  126.  
  127. for (s = 0; s < V; s++){
  128.  
  129. Visited[s] = false;
  130.  
  131. Dist[s] = COST_NO_LINK; // 初始最大距离
  132.  
  133. }
  134.  
  135. // 首先选v0到v0的距离一定最短，最终数据
  136.  
  137. Visited[v0] = true;
  138.  
  139. Dist[v0] = 0;
  140.  
  141. s = v0; // 0 预先选中v0点
  142.  
  143. for (i = 0; i < V; i++){
  144.  
  145. //更新该点到其他未选中点的最短路径
  146.  
  147. for (w = 0; w < V; w++){
  148.  
  149. if (!Visited[w] && Cost[s][w] < COST_NO_LINK&& Dist[w] > Dist[s] + Cost[s][w]){
  150.  
  151. Dist[w] = Dist[s] + Cost[s][w];
  152.  
  153. }
  154.  
  155. }
  156.  
  157. //如果在中间过程找到了目标点v1，则不再继续计算了
  158.  
  159. if (s == v1){
  160.  
  161. Cache[v0][v1] = Dist[s];
  162.  
  163. Cache[v1][v0] = Dist[s];
  164.  
  165. return Dist[s];
  166.  
  167. }
  168.  
  169. //选中相应点
  170.  
  171. min = COST_NO_LINK;
  172.  
  173. for (w = 0; w < V; w++){
  174.  
  175. if (!Visited[w] && Dist[w] < min){
  176.  
  177. minIndex = w;
  178.  
  179. min = Dist[w];
  180.  
  181. }
  182.  
  183. }
  184.  
  185. s = minIndex;
  186.  
  187. Visited[s] = true;
  188.  
  189. }
  190.  
  191. }
  192.  
  193.  
  194.  
  195. // 图的连通性测试
  196.  
  197. bool ConnectivityTest(int start, bool& bNoPoints){
  198.  
  199. set<int> nodeSet; // 连通顶点集
  200.  
  201. vector<int> test_nodes; // 与新加入连通点连通的未加入点集
  202.  
  203. set<int> singlePoints; // 图中的单点集
  204.  
  205. int i, j;
  206.  
  207. // 先找出单点
  208.  
  209. bool hasEdge = false;
  210.  
  211. for (i = 0; i < V; i++){
  212.  
  213. hasEdge = false;
  214.  
  215. // 这里起始应该是0，不然最后一个点如果是单点则无法判断
  216.  
  217. for (j = 0; j < V; j++) {
  218.  
  219. if (Graph[i][j] > 0){
  220.  
  221. hasEdge = true;
  222.  
  223. break;
  224.  
  225. }
  226.  
  227. }
  228.  
  229. if (!hasEdge){
  230.  
  231. singlePoints.insert(i);
  232.  
  233. }
  234.  
  235. }
  236.  
  237. // 设置bNoPoints标志
  238.  
  239. bNoPoints = (singlePoints.size() == V);
  240.  
  241. // start点必须在连通图中
  242.  
  243. if (singlePoints.find(start) != singlePoints.end()) {
  244.  
  245. return false;
  246.  
  247. }
  248.  
  249. test_nodes.push_back(start);
  250.  
  251.  
  252.  
  253. while (test_nodes.size() > 0){
  254.  
  255. int testNode = test_nodes.back();
  256.  
  257. test_nodes.pop_back();
  258.  
  259. for (i = 0; i < V; i++){
  260.  
  261. if (Graph[testNode][i] > 0){
  262.  
  263. if (nodeSet.insert(i).second){
  264.  
  265. test_nodes.push_back(i);
  266.  
  267. }
  268.  
  269. }
  270.  
  271. }
  272.  
  273. }
  274.  
  275.  
  276.  
  277. for (i = 0; i < V; i++){
  278.  
  279. // 存在点既不是单点，也不在当前连通顶点集中，则这个点一定在其他连通子图中，返回假
  280.  
  281. if (singlePoints.find(i) == singlePoints.end()&& nodeSet.find(i) == nodeSet.end()){
  282.  
  283. return false;
  284.  
  285. }
  286.  
  287. }
  288.  
  289. return true;
  290.  
  291. }
  292.  
  293.  
  294.  
  295. // 测试图中是否有度为奇的顶点，结果保存在中，返回奇度顶点数
  296.  
  297. int OddTest(){
  298.  
  299. int i, j, rSum, count;
  300.  
  301. // 初始化
  302.  
  303. for (i = 0; i < V; i++){
  304.  
  305. Odd_Group[i] = 0; // 0表示不为奇
  306.  
  307. Best_Group[i] = 0;
  308.  
  309. }
  310.  
  311. count = 0;
  312.  
  313. for (i = 0; i < V; i++){
  314.  
  315. rSum = 0;
  316.  
  317. for (j = 0; j < V; j++){
  318.  
  319. rSum += Graph[i][j]; // 求i行和
  320.  
  321. }
  322.  
  323. if (rSum % 2 == 1){
  324.  
  325. Odd_Group[i] = 1;
  326.  
  327. count++;
  328.  
  329. }
  330.  
  331. }
  332.  
  333. return count;
  334.  
  335. }
  336.  
  337. //当前最优分组
  338.  
  339. void Best_Grouping(){
  340.  
  341. int i;
  342.  
  343. for (i = 0; i < V; i++){
  344.  
  345. Best_Group[i] = Odd_Group[i];
  346.  
  347. }
  348.  
  349. }
  350.  
  351. // 对奇度顶点进行分组，level值从2开始取值。
  352.  
  353. // 返回值表示当前这种分组是否是当前所找到中的最好分组。
  354.  
  355. bool Grouping(int level){
  356.  
  357. int i, j, findI = -1;
  358.  
  359. for (i = 0; i < V; i++){
  360.  
  361. if (Odd_Group[i] == 1){
  362.  
  363. Odd_Group[i] = level; // 找到第一个组合点。
  364.  
  365. findI = i;
  366.  
  367. break;
  368.  
  369. }
  370.  
  371. }
  372.  
  373. bool re = true;
  374.  
  375. // 这里是形成一对新的组合后的地方，此时应该计算各组合最小路径之和。
  376.  
  377. if (findI == -1)  {
  378.  
  379. int weightSum = 0;
  380.  
  381. // 根据level的值可以知道分组的取值是从2到level-1的，所以i如是计数
  382.  
  383. for (i = 2; i < level; i++) {
  384.  
  385. int index[2];
  386.  
  387. int* pIndex = index;
  388.  
  389. for (j = 0; j < V; j++){
  390.  
  391. if (Odd_Group[j] == i){
  392.  
  393. *pIndex = j;
  394.  
  395. // 设置了第二个index值
  396.  
  397. if (pIndex == index + 1) {
  398.  
  399. break;
  400.  
  401. }
  402.  
  403. pIndex++;
  404.  
  405. }
  406.  
  407. }
  408.  
  409. weightSum += Dijstra(index[0], index[1], true); // 这里暂时只计算最短路权值和，不实际上添加边，最后才添加。这样加边计算只会调用一次。
  410.  
  411. }
  412.  
  413. // 当前组合比以往要优，将当前的排列组合情况更新到全局
  414.  
  415. if (weightSum < Shortest_Path_Weight) {
  416.  
  417. Best_Grouping(); // 如果当前分组比以往都好，备份一下
  418.  
  419. Shortest_Path_Weight = weightSum;
  420.  
  421. return true; // 找到了更优组合，返回递归调用为真
  422.  
  423. }
  424.  
  425. else{
  426.  
  427. return false; // 没找到了更优组合，返回递归调用为假
  428.  
  429. }
  430.  
  431. }
  432.  
  433. else if (findI > -1){
  434.  
  435. // 上面找到了第一个点了，现在从上面继续找第二个点。
  436.  
  437. for (/* 继续上面的for */; i < V; i++){
  438.  
  439. // 找到第二个点
  440.  
  441. if (Odd_Group[i] == 1) {
  442.  
  443. Odd_Group[i] = level;
  444.  
  445. re = Grouping(level + 1);
  446.  
  447. Odd_Group[i] = 1; // 无论当前分组是不是当前最好分组，我们都还要继续查找剩余分组情况
  448.  
  449. }
  450.  
  451. }
  452.  
  453. }
  454.  
  455. else{
  456.  
  457. cerr << "findCount值异常" << endl;
  458.  
  459. exit(-1);
  460.  
  461. }
  462.  
  463.  
  464.  
  465. if (findI > -1){
  466.  
  467. Odd_Group[findI] = 1; // 无论当前分组是不是最好分组，我们都还要继续查找剩余分组情况
  468.  
  469. }
  470.  
  471.  
  472.  
  473. return re;
  474.  
  475. }
  476.  
  477. //加边
  478.  
  479. void AddShortPath(int from, int to){
  480.  
  481. int i, back;
  482.  
  483. Dijstra(from, to, false); // 求最短路径，结果在dist数组中
  484.  
  485. back = to;
  486.  
  487. // from ... back ... to
  488.  
  489. while (back != from) {
  490.  
  491. for (i = 0; i < V; i++){
  492.  
  493. if (i != back&& Dist[i] < COST_NO_LINK&& Dist[back] < COST_NO_LINK && Dist[i] + Cost[i][back] == Dist[back]){
  494.  
  495. Graph[i][back]++; // 添加一条边
  496.  
  497. Graph[back][i]++;
  498.  
  499. back = i;
  500.  
  501. break;
  502.  
  503. }
  504.  
  505. }
  506.  
  507. }
  508.  
  509. }
  510.  
  511. // 根据odd数组的分组情况添加最短路径
  512.  
  513. void AddShortPaths(){
  514.  
  515. int i, j;
  516.  
  517. for (i = 0; i < V; i++){
  518.  
  519. if (Best_Group[i] > 1){
  520.  
  521. for (j = i + 1; j < V; j++){
  522.  
  523. if (Best_Group[j] == Best_Group[i]){
  524.  
  525. AddShortPath(i, j);
  526.  
  527. break;
  528.  
  529. }
  530.  
  531. }
  532.  
  533. }
  534.  
  535. }
  536.  
  537. }
  538.  
  539. // 处理图中可能存在度为奇的情况
  540.  
  541. void OddDeal(){
  542.  
  543. // 判断是否存在为奇的点，有的话要处理
  544.  
  545. int oddCount = OddTest();
  546.  
  547. if (oddCount > 0){
  548.  
  549. // 对为奇的点进行排列组合。。。
  550.  
  551. Grouping(2); // 这里得到的odd2是最优的
  552.  
  553. AddShortPaths(); // 根据odd数组添加最短路径
  554.  
  555. }
  556.  
  557. }
  558.  
  559. /*
  561. 用Fleury算法求最短欧拉回游
  563. 假设迹wi=v0e1v1…eivi已经选定，那么按下述方法从E-｛e1,e2,…,ei｝中选取边ei+1:
  565. 1)、 ei+1与vi+1相关联；
  567. 2)、除非没有别的边可选择，否则 ei+1不能是Gi=G-｛e1,e2,…,ei｝的割边。
  569. 3)、 当(2)不能执行时，算法停止。
  571. */
  572.  
  573. void Fleury(int start) {
  574.  
  575. int i;
  576.  
  577. int vi = start; // v0e1v1…eivi已经选定
  578.  
  579. bool bNoPoints, bCnecTest;
  580.  
  581. cout << "你要的结果：";
  582.  
  583. while (true) {
  584.  
  585. // 找一条不是割边的边ei+1
  586.  
  587. for (i = 0; i < V; i++) {
  588.  
  589. if (Graph[vi][i] > 0) {
  590.  
  591. // 假设选定（vi，i）这条边
  592.  
  593. Graph[vi][i]--; // 这里会破坏全局Graph的值，但暂时没影响了，都不用了。
  594.  
  595. Graph[i][vi]--;
  596.  
  597. bCnecTest = ConnectivityTest(i, bNoPoints);
  598.  
  599. if (!bNoPoints && !bCnecTest) {
  600.  
  601. Graph[vi][i]++;
  602.  
  603. Graph[i][vi]++;
  604.  
  605. continue;
  606.  
  607. }
  608.  
  609. // 选定（vi，i）这条边
  610.  
  611. cout << (char)('a' + vi) << "->" << (char)('a' + i) << " ";
  612.  
  613. sumWeight += Cost[vi][i];
  614.  
  615. vi = i;
  616.  
  617. break;
  618.  
  619. }
  620.  
  621. }
  622.  
  623. if (i == V) {
  624.  
  625. cout << endl;
  626.  
  627. break; // 到这里边找完了
  628.  
  629. }
  630.  
  631. }
  632.  
  633. }
  634.  
  635.  
  636.  
  637. //主函数
  638.  
  639. int main() {
  640.  
  641. //输入图的数据
  642.  
  643. Input();
  644.  
  645. bool b;
  646.  
  647. if (!ConnectivityTest(0, b))
  648.  
  649. {
  650.  
  651. cout << "该图不是连通图！\n";
  652.  
  653. exit(0);
  654.  
  655. }
  656.  
  657. OddDeal(); // 处理可能的奇度点情况
  658.  
  659. Fleury(SP); // 用Fleury算法求欧拉回游
  660.  
  661. cout << "最优邮路的长度为：" << sumWeight << endl;
  662.  
  663. return 0;
  664.  
  665. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/爱喝兽奶帝天荒/article/detail/785096
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号