货郎担问题算法 c语言实现,求解货郎担问题的分枝限界算法

最新推荐文章于 2021-08-28 12:17:29 发布
最新推荐文章于 2021-08-28 12:17:29 发布
阅读量1k 收藏 6
点赞数 1

A*算法 最短路径 图论 路径搜索 矩阵操作
关键词由CSDN通过智能技术生成

#include

#include

#include

#define TRUE (1)

#define FALSE (0)

#define MAX_CITIES (10)

#define INFINITY (999)

#define I INFINITY

typedef int bool;

typedef struct _EDGE {

int head;

int tail;

} EDGE;

typedef struct _PATH {

EDGE edge[MAX_CITIES];

int edgesNumber;

} PATH;

typedef struct _MATRIX {

int distance[MAX_CITIES][MAX_CITIES];

int citiesNumber;

} MATRIX;

typedef struct _NODE {

int bound; MATRIX matrix; PATH path; struct _NODE* left; struct _NODE* right; } NODE;

int Simplify(MATRIX*);

EDGE SelectBestEdge(MATRIX);

MATRIX LeftNode(MATRIX, EDGE);

MATRIX RightNode(MATRIX, EDGE, PATH);

PATH AddEdge(EDGE, PATH);

PATH BABA(NODE);

PATH MendPath(PATH, MATRIX);

int MatrixSize(MATRIX, PATH);

void ShowMatrix(MATRIX);

void ShowPath(PATH, MATRIX);

main()

{

PATH path;

NODE root = {

0,

{{{I, 1, 2, 7, 5},

{1, I, 4, 4,

3},

{2, 4, I, 1,

2},

{7, 4, 1, I,

3},

{5, 3, 2, 3,

I}}, 5},

{{0}, 0},

NULL, NULL

};

root.bound += Simplify(&root.matrix);

path = BABA(root);

ShowPath(path, root.matrix);

return 0;

}

PATH BABA(NODE root)

{

int i;

static int minDist = INFINITY;

static PATH minPath;

EDGE selectedEdge;

NODE *left, *right;

puts("Current

Root:\n------------");

ShowMatrix(root.matrix);

printf("Root Bound:%d\n", root.bound);

if (MatrixSize(root.matrix, root.path) == 2)

{

if (root.bound <

minDist) {

minDist =

root.bound;

minPath =

MendPath(root.path, root.matrix);

getch();

return

(minPath);

}

}

selectedEdge = SelectBestEdge(root.matrix);

printf("Selected Edge:(%d, %d)\n",

selectedEdge.head + 1, selectedEdge.tail + 1);

left = (NODE *)malloc(sizeof(NODE));

right = (NODE *)malloc(sizeof(NODE));

if (left == NULL || right == NULL) {

fprintf(stderr,"Error

malloc.\n");

exit(-1);

}

left->bound = root.bound;

left->matrix =

LeftNode(root.matrix, selectedEdge);

left->path = root.path;

left->left = NULL;

left->right = NULL;

right->bound =

root.bound;

right->matrix =

RightNode(root.matrix, selectedEdge, root.path);

right->path =

AddEdge(selectedEdge, root.path);

right->left = NULL;

right->right = NULL;

left->bound +=

Simplify(&left->matrix);

right->bound +=

Simplify(&right->matrix);

root.left = left;

root.right = right;

puts("Right Branch:\n------------");

ShowMatrix(right->matrix);

puts("Left Branch:\n-----------");

ShowMatrix(left->matrix);

if (right->bound <

minDist) {

BABA(*right);

}

else {

printf("Current minDist is %d,

", minDist);

printf("Right Branch's Bound(=

%d).\n", right->bound);

printf("This branch is

dead.\n");

}

if (left->bound <

minDist) {

BABA(*left);

}

else {

printf("Current minDist is %d,

", minDist);

printf("Left Branch's Bound(=

%d).\n", left->bound);

printf("This branch is

dead.\n");

}

printf("The best answer now is %d\n",

minDist);

return (minPath);

}

PATH MendPath(PATH path, MATRIX c)

{

int row, col;

EDGE edge;

int n = c.citiesNumber;

for (row = 0; row < n;

row++) {

edge.head = row;

for (col = 0; col

< n; col++) {

edge.tail =

col;

if

(c.distance[row][col] == 0) {

path

= AddEdge(edge, path);

}

}

}

return path;

}

int Simplify(MATRIX* c)

{

int row, col, min_dist, h;

int n = c->citiesNumber;

h = 0;

for (row = 0; row < n; row++)

{

min_dist = INFINITY;

for (col = 0; col

< n; col++) {

if

(c->distance[row][col] < min_dist)

{

min_dist

= c->distance[row][col];

}

}

if (min_dist == INFINITY)

continue;

for (col = 0; col

< n; col++) {

if

(c->distance[row][col] != INFINITY) {

c->distance[row][col]

-= min_dist;

}

}

h += min_dist;

}

for (col = 0; col < n; col++)

{

min_dist = INFINITY;

for (row = 0; row

< n; row++) {

if

(c->distance[row][col] < min_dist)

{

min_dist

= c->distance[row][col];

}

}

if (min_dist == INFINITY)

continue;

for (row = 0; row

< n; row++) {

if

(c->distance[row][col] != INFINITY) {

c->distance[row][col]

-= min_dist;

}

}

h += min_dist;

}

return (h);

}

EDGE SelectBestEdge(MATRIX c)

{

int row, col;

int n = c.citiesNumber;

int maxD;

EDGE best, edge;

int D(MATRIX, EDGE);

maxD = 0;

for (row = 0; row < n; row++)

{

for (col = 0; col

< n; col++) {

edge.head =

row;

edge.tail =

col;

if

(!c.distance[row][col] && maxD < D(c, edge))

{

maxD

= D(c, edge);

best

= edge;

}

}

}

return (best);

}

int D(MATRIX c, EDGE edge)

{

int row, col, dRow, dCol;

int n = c.citiesNumber;

dRow = INFINITY;

for (col = 0; col < n; col++)

{

if (dRow <

c.distance[edge.head][col] && col != edge.tail) {

dRow =

c.distance[edge.head][col];

}

}

dCol = INFINITY;

for (row = 0; row < n; row++)

{

if (dCol <

c.distance[row][edge.tail] && row != edge.head) {

dCol =

c.distance[row][edge.tail];

}

}

return (dRow + dCol);

}

MATRIX LeftNode(MATRIX c, EDGE edge)

{

c.distance[edge.head][edge.tail] =

INFINITY;

return c;

}

MATRIX RightNode(MATRIX c, EDGE edge, PATH

path)

{

int row, col;

int n = c.citiesNumber;

EDGE loopEdge;

EDGE LoopEdge(PATH, EDGE);

for (col = 0; col < n;

col++)

c.distance[edge.head][col] =

INFINITY;

for (row = 0; row < n;

row++)

c.distance[row][edge.tail] =

INFINITY;

loopEdge = LoopEdge(path, edge);

c.distance[loopEdge.head][loopEdge.tail] =

INFINITY;

return (c);

}

EDGE LoopEdge(PATH path, EDGE edge)

{

int i, j;

EDGE loopEdge;

loopEdge.head = edge.tail;

loopEdge.tail = edge.head;

for (i = 0; i < path.edgesNumber;

i++) {

for (j = 0; j <

path.edgesNumber; j++) {

if

(loopEdge.head == path.edge[j].head) {

loopEdge.head

= path.edge[j].tail;

break;

}

}

}

for (i = 0; i < path.edgesNumber;

i++) {

for (j = 0; j <

path.edgesNumber; j++) {

if

(loopEdge.tail == path.edge[j].tail) {

loopEdge.tail

= path.edge[j].head;

break;

}

}

}

return (loopEdge);

}

PATH AddEdge(EDGE edge, PATH path)

{

path.edge[path.edgesNumber++] = edge;

return path;

}

int MatrixSize(MATRIX c, PATH path)

{

return (c.citiesNumber - path.edgesNumber);

}

void ShowPath(PATH path, MATRIX c)

{

int i, dist;

EDGE edge;

int n = path.edgesNumber;

dist = 0;

printf("\nThe path is: ");

for (i = 0; i < n; i++) {

edge = path.edge[i];

printf("(%d, %d) ", edge.head +

1, edge.tail + 1);

dist +=

c.distance[edge.head][edge.tail];

}

}

void ShowMatrix(MATRIX c)

{

int row, col;

int n = c.citiesNumber;

for (row = 0; row < n;

row++) {

for (col = 0; col

< n; col++) {

if

(c.distance[row][col] != INFINITY) {

printf("=",

c.distance[row][col]);

}

else {

printf(" -");

}

}

putchar('\n');

}

getch();

}

走丢了猫
关注
c语言编写的货郎担算法
08-06
c语言编写的货郎担算法，可以运行，大家参考参考
利用分支限界法解决01背包和货郎担问题
weixin_44415974的博客
07-01 1944
利用分支限界法解决01背包和货郎担问题详细步骤       posted @ 2018-11-23 13:48  Charlie_ODD  阅读(...)  评论(...)  编辑  收藏 ...
【计算机算法设计与分析】——7.3利用分支限界法解决01背包和货郎担问题
qq_38472535的博客
08-28 495
【计算机算法设计与分析】——7.3利用分支限界法解决01背包和货郎担问题
货郎担问题（分支限界法）
m0_51204608的博客
06-26 2258
#include<iostream> #include<fstream> using namespace std; typedef int Type; #define N 5 #define ZERO_VALUE_OF_TYPE 0 #define MAX_VALUE_OF_TYPE 2147483647 typedef struct node_data{ Type c[N][N]; //费用矩阵 int row_init[N]; //费用矩阵的当前行映射为
分支限界求解货郎担/旅行商问题
future200x的专栏
01-21 7259
分支限界求解货郎担/旅行商问题 http://blog.csdn.net/ly33854983/archive/2007/07/24/1705142.aspx/* 文件名：BoundleSalesMan.h 限界函数法 */ #pragma once #include "salesman.h" #include #include "Node.h" class BoundSa
货郎担分枝限界算法图形.rar_Branch and bound_分枝_分枝限界_货郎担_货郎担问题
09-21
在这个"货郎担 分枝限界算法图形.rar"压缩包中，包含的文件"b.c"可能是用C语言实现的分枝限界算法代码，它可能会定义数据结构（如节点和图的表示）、分枝操作、限界函数以及搜索策略等核心部分。而...
货郎担限界算法A.rar_货郎_货郎担
09-19
在提供的"货郎担限界算法.c"源代码文件中，可以学习到C语言实现货郎担限界算法的具体细节，包括数据结构的定义、路径的生成、限界的设定和交换操作的实现等。而"www.pudn.com.txt"可能是关于源代码的说明或者问题的...
蚁群算法计算34个城市货郎担问题 python
06-08
总之，通过蚁群算法解决34个城市货郎担问题，不仅展示了群体智能在解决复杂优化问题中的潜力，也为我们提供了理解并优化这类问题的一个实用工具。Python的实现方式使得这一算法更加亲民，便于学习和应用。
货郎担问题的算法实现
07-01
货郎担问题，又称旅行推销员问题（Travelling Salesman Problem, TSP），是运筹学中的一个经典问题，属于组合优化的范畴。在这个问题中，一个推销员需要访问n个城市，每个城市只能访问一次，并且最后返回出发城市，...
模拟退火算法求解货郎担问题（用C#实现）.zip
最新发布
03-29
在C#中实现模拟退火算法求解货郎担问题，我们需要以下几个关键步骤： 1. **数据结构**：首先，我们需要定义一个表示城市的数据结构，存储每个城市的位置（通常用坐标表示）。同时，构建一个邻接矩阵或邻接列表，...
货郎担问题算法以及详细说明.
07-15
这个是一个非常详细的货郎担算法的例子，内部有一个详细的API介绍
货郎担问题
04-06
离散数学的货郎担问题的课设 自己做的
TSP问题（货郎担问题)
12-22
货郎担问题的解决，很好用的哦，可以直接运行
货郎担的一般问题与分析
04-29
这个一个非常好的资源，可以解决一些最短路径问题啥的 ，就是挺好的 大家都来下哈
货郎问题的实例 c语言编程,货郎担问题的C语言解法
weixin_32514497的博客
05-18 1143
这是运筹学的货郎担问题的C语言解法。有菜单的。。#define N 5#include #includeint d[N][N];int Way[N];void Sort(int a[],int low,int up)//排序{int i,j,k,t;for(i=low+1;i<=up;i++)for(j=low;jif(a[j]>a[i]){t=a[i];for(k=i;k>j;...
分支限界法 旅行商 售货 问题 货郎问题
qq_44575910的博客
05-29 1299
用分支限界法解决旅行商问题。之前读书咋读读不懂，在网上也没找到啥好解释或者找到了也不是书中的同一种方法。 这几天啃书才读懂了一些。不得不说，书上设计的算法还是很巧妙的。 这里先给一些书上手写的解释，希望能对理解这个有所帮助。等过几天有空来详细讲一讲。 读的书是王晓东的《计算机算法设计与分析》。书中第六章分支限界法的内容。 谢谢阅读。 ...
C语言写货郎问题（贪心算法）
Wolf_xujie的博客
10-05 1149
这个是用c语言写的求解货郎问题的解，注意这是贪心算法，并不是动态规划，也就是说这个不一定是最优解 #include <stdio.h> #include <stdlib.h> #include <time.h> static int M_dis[100]; static int r[100]; static int distance[100][100]; st...
5.动态规划算法的设计与分析: 最短路径, 矩阵链, 递归实现, 迭代实现, 投资问题, 背包问题, 最长公共子序列
孤柒的博客
04-17 1235
本文内容为北大慕课课程的算法分析与设计的课程讲义,将其整理为OneNote笔记同时添加了本人上课时的课堂笔记,且主页中的思维导图就是根据课件内容整理而来, 为了方便大家和自己查看，特将此上传到CSDN博文中, 源文件已经上传到我的资源中,有需要的可以去看看, 我主页中的思维导图中内容大多从我的笔记中整理而来,相应技巧可在笔记中查找原题, 有兴趣的可以去 我的主页了解更多计算机学科的精品思维导图整理 本文可以转载，但请注明来处，觉得整理的不错的小伙伴可以点赞关注支持一下哦！ 博客中思维导图的高清...
元素判别值解货郎担问题：简化算法与实现
"货郎担问题的新解法及其算法设计" 货郎担问题，又称旅行商问题（Traveling Salesman Problem, TSP），是运筹学领域的一个经典问题，涉及到寻找最短路径的优化策略。该问题描述的是一个销售员需要访问n个城市的每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值