货郎担问题（分支限界法）

最新推荐文章于 2024-06-09 15:23:03 发布
最新推荐文章于 2024-06-09 15:23:03 发布
阅读量2.2k 收藏 29
点赞数 6
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51204608/article/details/118248588
版权 
#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];    //费用矩阵的当前行映射为原始行
	int col_init[N];    //费用矩阵的当前列映射为原始列
	int row_cur[N];     //费用矩阵的当前行映射为原始行
	int col_cur[N];     //费用矩阵的当前列映射为原始列
	int ad[N];          //回路顶点邻接表
	int k;              //当前费用矩阵的阶
	Type w;             //节点的下界
	struct node_data *next;    //队列链指针
}NODE;

Type c[N][N];
Type ad[N];
/*
NODE *xnode;          //父亲结点指针
NODE *ynode;          //儿子结点指针
NODE *znode;          //儿子结点指针
NODE *qbase;          //优先队列首指针
Type bound;          //当前可行解的最优值
*/

//计算node所指向结点的费用矩阵行row最小值
Type row_min(NODE *node,int row,Type &second)
{
	Type temp;
	int i;
	int flag=0;
	if(node->c[row][0] < node->c[row][1]){
		temp=node->c[row][0];
		second=node->c[row][1];
	}
	else{
		temp=node->c[row][1];
		second=node->c[row][0];
	}
	for(i=2;i<node->k;i++){
		if(node->c[row][i]<temp){
			second=temp;
			temp=node->c[row][i];
		}
		else if(node->c[row][i]<second)
			second = node->c[row][i];
	}

	for(i=0;i<node->k;i++)   //如果整行都是最大值则不进行归约，列同
		if(node->c[row][i]==MAX_VALUE_OF_TYPE)
			flag++;
	if(node->k==flag)
		return 0;
	return temp;
}

//计算node所指向结点的费用矩阵列col最小值
Type col_min(NODE *node,int col,Type &second)
{
	Type temp;
	int i;
	int flag=0;
	if(node->c[0][col] < node->c[1][col]){
		temp=node->c[0][col];
		second=node->c[1][col];
	}
	else{
		temp=node->c[1][col];
		second=node->c[0][col];
	}
	for(i=2;i<node->k;i++){
		if(node->c[i][col]<temp){
			second = temp;
			temp = node->c[i][col];;
		}
		else if(node->c[i][col]<second)
			second=node->c[i][col];
	}

	for(i=0;i<node->k;i++)
		if(node->c[i][col]==MAX_VALUE_OF_TYPE)
			flag++;
	if(node->k==flag)
		return 0;
	return temp;
}


//归约node所指向结点的费用矩阵
Type array_red(NODE *node)
{
	int i,j;
	Type temp,temp1,sum=ZERO_VALUE_OF_TYPE;
	for(i=0;i<node->k;i++){         //行归约
		temp=row_min(node,i,temp1);  //行归约常数
		for(j=0;j<node->k;j++){
			if(node->c[i][j]==MAX_VALUE_OF_TYPE)  //跳过最大值
				continue;
			node->c[i][j]-=temp;
		}
		sum += temp;                   //行归约常数累计
	}
	for(j=0;j<node->k;j++){         //列归约
		temp=col_min(node,j,temp1);  //列归约常数
		for(i=0;i<node->k;i++){
			if(node->c[i][j]==MAX_VALUE_OF_TYPE)  //跳过最大值
				continue;
			node->c[i][j]-=temp;
		}
		sum+=temp;                   //列归约常数累计
	}	
	return sum;                      //返回归约常数


}


//计算node所指向结点的费用矩阵Dkl,选择搜索分支的边
Type edge_sel(NODE *node,int &vk,int &vl)
{
	int i,j;
	Type temp,d=ZERO_VALUE_OF_TYPE;
	Type *row_value = new Type[node->k];
	Type *col_value = new Type[node->k];
	for(i=0;i<node->k;i++)                  //每一行的次小值
		row_min(node,i,row_value[i]);
	for(i=0;i<node->k;i++)                  //每一列的次小值
		col_min(node,i,col_value[i]);
	for(i=0;i<node->k;i++){     //对费用矩阵所有为0的元素计算相应的temp值
		for(j=0;j<node->k;j++){
			if(node->c[i][j]==ZERO_VALUE_OF_TYPE){
				temp=row_value[i]+col_value[j];
				if(temp>d){               //求最大的temp值d
					d=temp;
					vk=i;
					vl=j;                //保存相应的行列号
				}
			}
		}
	}
	delete row_value;
	delete col_value;
	return d;
}


//删除node所指向结点的费用矩阵第vk行第vl列的所有元素
void del_rowcol(NODE *node,int vk,int vl)
{
	int i,j,vk1,vl1;
	for(i=vk;i<node->k-1;i++)      //元素上移
		for(j=0;j<vl;j++)
			node->c[i][j] = node->c[i+1][j];
	for(j=vl;j<node->k-1;j++)      //元素左移
		for(i=0;i<vk;i++)
			node->c[i][j] = node->c[i][j+1];
	for(i=vk;i<node->k-1;i++)      //元素上移及左移
		for(j=vl;j<node->k-1;j++) 
			node->c[i][j] = node->c[i+1][j+1];
	vk1 = node->row_init[vk];   //当前行vk转换为原始行vk1
	node->row_cur[vk1] = -1;    //原始行删除标志
	for(i=vk1+1;i<N;i++)        //vk1之后的原始行，其对应的行号减一
		node->row_cur[i]--;
	vl1 = node->col_init[vl];   //当前列vl转换为原始列vl1
	node->col_cur[vl1]=-1;      //原始列删除标志
	for(i=vl1+1;i<N;i++)        //vl1之后的原始列，其对应的列号减一
		node->col_cur[i]--;
	for(i=vk;i<node->k-1;i++){  //修改vk及其之后的当前行的对应原始行号
		node->row_init[i] = node->row_init[i+1];
	}
	for(i=vl;i<node->k-1;i++)   //修改vl及其之后的当前列的对应原始列号
		node->col_init[i] = node->col_init[i+1];
	node->k--;                  //当前矩阵的阶数减一
}


//登记回路顶点邻接表，旁路有关的边
void edg_byp(NODE *node,int vk,int vl)
{
	int k,l;
	vk=node->row_init[vk];            //当前行号转换为原始行号
	vl=node->col_init[vl];             //当前列号转换为原始列号
	node->ad[vk]=vl;             //登记回路顶点邻接表
	k=node->row_cur[vl];        //vl转换为当前行号k
	l=node->col_cur[vk];        //vk转换为当前列号l
	if((k>0)&&(l>=0)){     //当行、列号均处于当前矩阵中旁路相应的边
		node->c[k][l] = MAX_VALUE_OF_TYPE;
	}
}

//初始化
NODE *initial(Type c[][N],int n)
{
	int i,j;
	NODE *node=new NODE;       //分配结点缓冲区
	for(i=0;i<n;i++)           //复制费用矩阵的初始数据
		for(j=0;j<n;j++){
			node->c[i][j]=c[i][j];
		}

		for(i=0;i<n;i++){       //建立费用矩阵原始行、列号与初始行、列号的关系
			node->row_init[i]=i;
			node->col_init[i]=i;
			node->row_cur[i]=i;
			node->col_cur[i]=i;
		} 
	for(i=0;i<n;i++){          //回路顶点邻接表初始化为空
		node->ad[i]=-1;
	}
	node->k=n; 
	return node;	          //返回结点指针
}

void Q_insert(NODE *qbase,NODE *xnode){
	NODE *p;
	if(qbase->next==NULL){
		qbase->next=xnode;
		xnode->next=NULL;
	}
	else if(xnode->w < qbase->next->w){
		xnode->next=qbase->next;
		qbase->next=xnode;
	}
	else{
		p=qbase->next;
		while(p->next){
			if((xnode->w > p->w)&&(xnode->w < p->next->w)){
				xnode->next=p->next;
				p->next=xnode;
				break;
			}
			p=p->next;
		}
		if(p->next==NULL){
			p->next=xnode;
			xnode->next=NULL;
		}
	}
	p=qbase->next;
	
}

NODE *Q_delete(NODE *qbase){
	NODE *p;
	p=qbase->next;
	qbase->next=p->next;
	return p;
}

//货郎担问题的分支限界算法
template <class Type>
Type traveling_salesman(Type c[][N],int n,int ad[])
{
	int i,j,vk,vl;
	Type d,w,bound=MAX_VALUE_OF_TYPE;
	NODE *xnode,*ynode,*znode,*qbase;
	qbase=new NODE;
	qbase->next=NULL;
	xnode=initial(c,n);        //初始化父亲结点		
	xnode->w = array_red(xnode);   //归约费用矩阵
	while(xnode->k!=0){			
		d=edge_sel(xnode,vk,vl);     //选择分支方向并计算Dkl
		znode=new NODE;             //建立分支结点（右儿子结点）
		*znode = *xnode;              //x结点的数据复制到z结点
		znode->c[vk][vl]=MAX_VALUE_OF_TYPE;	 //旁路Z结点的边		
					
		array_red(znode);            //归约z结点的费用矩阵		
		znode->w = xnode->w + d;       //计算z结点的下界
		if(znode->w<bound)             //若下界小于当前可行解最优值
			Q_insert(qbase,znode);     //z结点插入优先队列	
		else delete znode;             //否则剪去该结点		
		ynode=new NODE;             //建立分支结点（左儿子结点）
		*ynode=*xnode;              //x结点数据复制到y结点
		edg_byp(ynode,vk,vl);       //登记回路顶点的邻接表，旁路有关的边
		ynode->c[vl][vk]=MAX_VALUE_OF_TYPE;	
		del_rowcol(ynode,vk,vl);    //删除y结点费用矩阵当前vk行vl列
								
		ynode->w = array_red(ynode);  //归约y结点费用矩阵		
		ynode->w += xnode->w;        //计算y结点的下界
		if(ynode->k==2){             //费用矩阵只剩下2阶
			if((ynode->c[0][0] == ZERO_VALUE_OF_TYPE)&&
				(ynode->c[1][1] == ZERO_VALUE_OF_TYPE)){
				ynode->ad[ynode->row_init[0]] = ynode->col_init[0];
				ynode->ad[ynode->row_init[1]] = ynode->col_init[1];
			}
			else{
				ynode->ad[ynode->row_init[0]] = ynode->col_init[1];
				ynode->ad[ynode->row_init[1]] = ynode->col_init[0];
			}                         //登记最后两条边
			ynode->k=0;
		}
		if(ynode->w<bound){          //若下界小于当前可行解最优值
			Q_insert(qbase,ynode);   //y结点插入优先队列
			if(ynode->k==0)          //更新当前可行解最优值
				bound = ynode->w;
		}
		else delete ynode;    //否则剪去y结点
		xnode=Q_delete(qbase);   //取优先队列首元素
	} 
	w=xnode->w;               //保存最短路线费用
	for(i=0;i<n;i++){         //保存路线的顶点邻接表
		ad[i]=xnode->ad[i];
	}
	delete xnode;              //释放x结点的缓冲区
	while(qbase->next){             //释放队列结点缓冲区
		xnode = Q_delete(qbase);
		delete xnode;
	} 
	return w;            //回送最短路线费用
}

void main(){
	int i,j;
	ifstream fin("1.txt");
	if(!fin){
		cout<<"cannpt open file!"<<endl;
		exit(0);
	}
	for(i=0;i<N;i++)
		for(j=0;j<N;j++){
			fin>>c[i][j];
		}
	fin.close();
	cout<<"最小费用为:\n";
	cout<<traveling_salesman(c,N,ad)<<endl;
	cout<<"回路顶点邻接表登记情况为："<<endl;
	cout<<"\t";
	for(i=0;i<N;i++)
		cout<<i<<"\t";
	cout<<endl;
	cout<<"ad:\t";
	for(i=0;i<N;i++)
		cout<<ad[i]<<"\t";
	cout<<endl;
}

fiel(1.text):
在这里插入图片描述
运行结果：
在这里插入图片描述

艺兴的小贝壳
关注
  • 6
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
货郎担分枝限界算法图形.rar_Branch and bound_分枝_分枝限界_货郎担_货郎担问题
09-21
货郎担问题，又称旅行...总的来说，分枝限界法是一种强大的工具，尤其适用于解决货郎担这类组合优化问题。通过图形化的演示，我们可以直观地理解算法的工作原理，加深对运筹学方法的理解，并提高解决实际问题的能力。
依靠队列搜索——分支限界法及其应用：最大团问题、货郎问题
qq_41926985的博客
04-29 8568
人生是需要做好规划的，就算是混这人生也要混出个名堂出来。 全国有大部分人知道考研，但是考出来干什么，走什么的路是真的没有想法。 计算机行业涉及到许许多多的领域，所以，大学期间要学计算机专业，一定要做好规划，想做什么才能去学什么。囫囵吞枣只会让你啥也没有学到，说明白点就只是让你明白个大概，而不能明白所以然。 所以要定好方向，，将来想干什么，然后在这条路上学懂专业，这样到了社会，才能给你这一席之地。 ...
分支限界求解货郎担/旅行商问题
世界的边际的专栏
07-24 6925
 /*  文件名：BoundleSalesMan.h   限界函数法   */#pragma once#include "salesman.h"#include #include "Node.h"class BoundSalesMan :     public SalesMan{protected:     int SetIMatrix(int i,int
分支限界法求货郎担问题
最新发布
m0_62168175的博客
06-09 50
【代码】分支限界法求货郎担问题。
利用分支限界法解决01背包和货郎担问题
weixin_44415974的博客
07-01 1895
利用分支限界法解决01背包和货郎担问题详细步骤       posted @ 2018-11-23 13:48  Charlie_ODD  阅读(...)  评论(...)  编辑  收藏 ...
旅行商问题
m0_53233211的博客
06-24 2016
旅行商问题（C++） 运用优先队列分支限界法 问题描述 旅行商问题（Traveling Salesman Problem，TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该推销员从一个城市出发，需要求得经过所有城市后，回到出发地的最小路径成本。 该问题的实质是从图论的角度来看，该问题实质是在一个带权完全无向图中，找一个权值最小的哈密顿回路。 解决方法 分支限界法：利用贪心方法求得上界，，优先队列式分支限界法用优先队列存储活结点表 算法分析 -对于TSP（旅行商
货郎问题：回溯法和限界分支法
weixin_40759186的博客
12-05 4349
这个问题可以堪称一个全排列，[起点，剩下的全排列] import numpy as np class backtracking_Traveling_saleman: # 初始化，明确起点 def __init__(self,graph,start=0): # 顶点的个数 self.vertex_num = len(graph) se...
分支限界法（优先队列）求旅行商问题
qq_55225576的博客
07-01 6959
1、问题描述： 旅行商问题（Traveling Salesman Problem，TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该问题是在寻求单一旅行者由起点出发，通过所有给定的需求点之后，最后再回到原点的最小路径成本。最早的旅行商问题的数学规划是由Dantzig等人提出。 要求：随机生成顶点数为n的图，利用优先队列式分支限界法完成旅行商问题求解。 2、分支限界法： 分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。在分支限界法中，每一个活
【算法导论12】分支限界法—01背包问题
qq_37739859的博客
10-13 9964
【算法导论12】分支限界法—01背包问题 问题描述： 一个背包有固定体积和容量两个参数，针对n件商品，商品包含体积和价值两个参数，如何选择商品的装入，使得背包所装入的总价值最大。 问题分析： 一个商品有装和不装两种状态，因此此问题的解可以用一颗二叉树来表示，二叉树根节点到叶节点的路径穷举就是所有的选择。在此基础上，再删去不符合条件的结点路线即可。下面对此算法进行优化： 考虑三个问题： 1、如何确定某个结点选还是不选。 2、如何设计算法实现当某个结点已经不符合限制或最优解时，对结点进行剪枝。 3、如何设计算法
货郎担分枝限界图形计算程序
09-26
货郎担分枝限界图形演示的c语言计算程序，直接运行即可
算法分析与设计课件：分支限界法.ppt
09-21
我们也学习了如何使用分支限界法来解决非对称的货郎担问题。 分支限界法是一种强大的工具，可以用于解决复杂的组合优化问题。通过了解分支限界法的工作原理和算法流程，我们可以更好地应用该方法来解决实际问题。 ...
优先队列式分支限界法解决旅行商问题.zip
04-22
旅行商问题（TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该问题是在寻求单一旅行者由起点出发，通过所有给定的需求点之后，最后再回到原点的最小路径成本。 “旅行商问题”常被...
TSP货郎担问题的研究与实现
02-28
总结起来，货郎担问题的研究与实现涉及了组合优化、NP完全问题理论、分支限界法的原理与应用，以及C++编程技巧。通过深入理解这些问题和方法，我们可以设计出更高效的算法，解决实际生活中的复杂优化问题。
【计算机算法设计与分析】——7.3利用分支限界法解决01背包和货郎担问题
qq_38472535的博客
08-28 486
【计算机算法设计与分析】——7.3利用分支限界法解决01背包和货郎担问题
货郎担问题算法 c语言实现,求解货郎担问题的分枝限界算法
weixin_36149065的博客
05-25 1055
#include#include #include #define TRUE (1)#define FALSE (0)#define MAX_CITIES (10)#define INFINITY(999)#define I INFINITYtypedef int bool;typedef struct _EDGE {int head;int tail;} EDGE;typedef struct...
算法-分支限界法
热门推荐
10-24 1万+
回溯法是深度优先策略遍历问题的解空间树。分支限界法按广度优先策略遍历问题的解空间树，在遍历过程中对已经处理的每一个节点根据衔接函数估算目标函数的可能取值，从中选取使目标函数取得极值(极大或极小)的节点优先进行广度优先搜索，从而不断调整搜索方向，尽快找到问题的解。 概述 解空间树的动态搜索 分支限界法首先确定一个合理的限界函数，并根据限界函数确定目标函数的界[down,up]，然后，按照广度优先策略遍历问题的解空间树，在分支节点上，一次搜索该节点的所有孩子节点，分别估算这些孩子节点的目标函数的可能取值，如果某
常用算法的伪代码
Wolf_xujie的博客
11-02 9253
一、分治策略 分（Divide） 将规模为n的问题分解为 k 个规模较小的子问题 治（Conquer） 对k个子问题分别求解，然后将各个子问题的解合并得到原问题的解 分治策略是从下至上求解并将合并得到解 Begin 输入有序数组a[],查找元素x,数组最左边下标i，最右边下标j i->0,j->a.length 1.while(i<=j)循环执行: ...
算法第四次作业-分支限界法求解作业分配问题
小红花yu
11-30 8809
一、运行环境： Win7、Spyder、Python3.7 二、运行过程说明: 数据文件格式：输入数据来源于文件，input_assign04_0*.dat。文件内是n*n矩阵的元素，每行的元素代表每个工人完成该任务所需要的时间，每列代表某个工人完成每个工作需要的时间，读出的数据放在嵌套了列表的列表matrix中。 输入格式： 在Spyder中运行程序，输入测试数据集文件编号。...
分支限界法求解货郎问题伪码
07-12
下面是使用分支限界法求解货郎问题的伪码： ``` class City: def __init__(self, name, distance): self.name = name self.distance = distance def tsp(cities): n = len(cities) path = [0] * (n + 1) visited = [False] * n best_path = [0] * (n + 1) best_distance = float('inf') def calculate_distance(path): total_distance = 0 for i in range(n): total_distance += cities[path[i]].distance[path[i+1]] return total_distance def branch_and_bound(curr_city, curr_distance, depth): nonlocal best_distance, best_path if depth == n: curr_distance += cities[curr_city].distance[0] if curr_distance < best_distance: best_distance = curr_distance best_path = path.copy() for i in range(1, n): if not visited[i]: path[depth] = i visited[i] = True new_distance = curr_distance + cities[curr_city].distance[i] if new_distance < best_distance: branch_and_bound(i, new_distance, depth + 1) visited[i] = False branch_and_bound(0, 0, 0) return best_path, best_distance ``` 这段伪码实现了一个`City`类来表示每个城市，其中包含了城市的名称和与其他城市的距离。`tsp`函数使用分支限界法来解决货郎问题。它通过递归地在每个节点处进行分支和限界来搜索最优路径。`path`列表用于保存当前的路径，`visited`列表用于标记已经访问过的城市。`best_path`和`best_distance`分别用于保存最优路径和最小距离。`calculate_distance`函数用于计算给定路径的总距离。`branch_and_bound`函数是核心的分支限界算法实现，它通过遍历每个未访问过的城市进行分支，并在每个节点处进行限界剪枝判断。最终，函数返回最优路径和最小距离。 请注意，这只是一个简化的伪码示例，实际的实现可能需要更多的优化和边界条件处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值