算法设计与分析实验四：利用回溯法求解01背包问题和TSP问题

最新推荐文章于 2023-10-19 14:23:40 发布
最新推荐文章于 2023-10-19 14:23:40 发布
阅读量1.8k 收藏 29
点赞数
分类专栏： 算法设计与分析实验 文章标签： 算法 图论 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61996033/article/details/130262893
版权

算法实验四


【实验内容】
（1）利用回溯法编程求解0-1背包问题，并对算法进行时间复杂性分析；
（2）利用回溯法编程求解TSP问题，并对算法进行时间复杂性分析。
【编译环境】devc++ 5.11
【解题思路】
01背包问题：
1.获取背包容量packvol，物品数量n，物品价值和重量value[],weigth[]

2.确定剪枝方法

3.回溯法求解01背包问题

4.对于复杂性
【参考内容】
一、
什么是剪枝？
剪枝一种可以提高搜索算法时间和空间效率的技巧，经过剪枝和其他优化策略优化过的算法在执行效率上远超一般未经剪枝的算法。甚至有些暴力搜索过不了时限的算法，也可以通过各种剪枝+优化大大缩短算法运行时间，成功通过时效限制。由此可见剪枝对于搜索算法的重要性。因此，剪枝对于学习算法和在工作中与算法打交道的人来说都是一类不得不学的知识点。
对于本问题来说：
剪枝的具体实现在于，如何尽量减少不能得到正确答案的运算。例如在使用回溯法穷举物品装入背包时，已知目前装入的物品总重量已经超过了背包容量，就可以直接判断之后的物品不会在装入背包。从而达到提前回溯的目的。
二、
算法参考了《算法设计与分析第二版》154页的例题素数环问题。但是例题的时间复杂度为n的n次方，所以进行了一些改进，最终时间复杂度达到了2的n次方。
【代码分析】

一、01背包问题

数据生成和表示

数据写入到cpp对应目录下的txt文本文件中
头文件和用于生成数据的函数声明

#include<stdio.h>
#include<time.h>
#include<random>

//宏定义区 
#define MAX 30//背包最大容量 
#define MAXN 30//最大物品数 
#define MAXW 7//物品最大重量 
#define MAXV 7//物品最大价值 

//自定义函数区 
void randomint(int,int,int*,int*);//生成随机数并调用fwritein函数写入文件 
void fwritein(int,int,int*,int*);//将数据写入文件方便分析

函数定义和调用

void fwritein(int packvol,int n,int* weight,int* value)
{
	FILE* fp = fopen("demo4-1.TXT","w");
	fprintf(fp,"背包容量：%d\n",packvol);
	fprintf(fp,"物品数量：%d\n",n);
	for(int i=0;i<n;i++)
	{
		fprintf(fp,"%d\t%d\t%d\n",i,weight[i],value[i]);
	}
	fclose(fp);
}

void randomint(int packvol,int n,int* weight,int* value)
{
	for(int i=0;i<n;i++)
	{
		weight[i]=rand()%MAXW+1;
		value[i]=rand()%MAXV+1;
	}
	fwritein(packvol,n,weight,value);
	return;
}


int main()
{
	//输入背包问题所需数组信息 
	int n,packvol;
	srand(time(NULL));
	n = rand()%MAXN+1;
	packvol = rand()%MAX+1;
	int w[n],v[n];
	randomint(packvol,n,w,v);
	Pack(n,packvol,w,v);//01背包问题算法
	
	return 0;
}

处理数据需要使用的函数和功能

检查背包中是否有要装入的物品

bool check(int packvol,int w,int k,int*packin)//背包容量，当前背包重量，当前遍历层数，记录遍历情况的数组 
{
	if(w>packvol)
		return false;
	for(int i=0;i<k;i++)
	{
		if(packin[i]==packin[k])
			return false;
	}
	return true;
}

输出运算结果

void print(int* packin,int maxv,int n)
{
	for(int i=0;i<n;i++)
	{
		if(packin[i]!=-1)
		{
			printf("装入物品:编号%-4d\n",packin[i]);
		}
	}
	printf("背包最大价值:%d\n\n",maxv);
}

01背包问题算法实现

推荐在看下面代码之前看一下相应算法书上的约瑟夫环算法的实现方法。
下面的方法并不是模仿二叉树进行的回溯法。

//借鉴算法书154页素数环问题做的.
void Pack(int n,int packvol,int* weight,int* value)//物品数，背包容量，重量数组，价值数组
{
	int packin[n];//记录物品的装入情况
	int w=0;//每次回溯过程中记录物品重量 
	int v=0;//物品价值
	int maxv=0;//最大价值 
	int k=0; 
	for(int i=0;i<n;i++)//初始化 
	{
		packin[i]=-1;
	}
	while(k>=0)
	{
		//packin[k]!=-1表示此种情况可能是经过回溯得到的，或者正在遍历 
		if(packin[k]!=-1)
		{
			w=w-weight[packin[k]];
			v=v-value[packin[k]];
			packin[k]=packin[k]+1;
		}
		//packin[k]==-1表示此种情况还未经过遍历 
		else
		{
			//这两个if else时为了减少时间复杂度
			//k！=0时可以直接在 packin[k-1]+1进行后面的遍历，因为背包中物品装入的顺序不会影响背包的价值。 
			if(k==0)
			{
				packin[k]=packin[k]+1;
			}
			else
				packin[k]=packin[k-1]+1;
		}
		//packin[k]表示物品编号,最大为n-1，当其值为n时表示当前情况已经全部遍历 
		if(packin[k]!=n)
		{
			w=w+weight[packin[k]];
			v=v+value[packin[k]];
		}
		//packin[k]所代表的物品是否额可以装入装入背包 
		while(packin[k]<n) 
		{
			if(check(packvol,w,k,packin)==true)
			{
				break;
			}
			else
			{
				w=w-weight[packin[k]];
				v=v-value[packin[k]];
				packin[k]=packin[k]+1;
				if(packin[k]!=n)
				{
					w=w+weight[packin[k]];
					v=v+value[packin[k]];
				}
			}
		}
		//三种情况 
		//满足剪枝条件，判断当前结果是否相对最优 
		//背包满了 
		if(packin[k]==n)
		{
			if(v>maxv)
			{
				maxv = v;
				print(packin,maxv,n);
			} 
			packin[k--]=-1;
		}
		//到达叶子节点，进行回溯 
		//背包不一定满但是物品装完了 
		else if(k==n-1) 
		{
			if(v>maxv)
			{
				maxv = v;
				print(packin,maxv,n);
			}
			w=w-weight[packin[k]];
			v=v-value[packin[k]];
			packin[k--]=-1;
		}
		//判断下一个节点 
		//背包没满物品也没装完 
		else if(k<n-1)
		{
			k=k+1;
		}
	}
}

数据

回溯法01背包问题数据

输出

回溯法01背包问题输出

复杂度

回溯法01背包复杂度分析

01背包问题源代码

#include<stdio.h>
#include<time.h>
#include<random>

//宏定义区 
#define MAX 20//背包最大容量 
#define MAXN 15//最大物品数 
#define MAXW 7//物品最大重量 
#define MAXV 7//物品最大价值 

//自定义函数区 
void randomint(int,int,int*,int*);//生成随机数并调用fwritein函数写入文件 
void fwritein(int,int,int*,int*);//将数据写入文件方便分析 
void Pack(int,int,int*,int*);//01背包问题主要算法	参数含义： 物品数，背包容量，重量数组，价值数组
bool check(int,int,int,int*);//检查某个物品是否可以装入当前背包  参数含义: 背包容量，当前背包重量，当前遍历层数，记录遍历情况的数组 
void print(int*,int,int); //自定义打印函数 



bool check(int packvol,int w,int k,int*packin)//背包容量，当前背包重量，当前遍历层数，记录遍历情况的数组 
{
	if(w>packvol)
		return false;
	for(int i=0;i<k;i++)
	{
		if(packin[i]==packin[k])
			return false;
	}
	return true;
}

void print(int* packin,int maxv,int n)
{
	for(int i=0;i<n;i++)
	{
		if(packin[i]!=-1)
		{
			printf("装入物品:编号%-4d\n",packin[i]);
		}
	}
	printf("背包最大价值:%d\n\n",maxv);
}

//借鉴算法书154页素数环问题做的.
void Pack(int n,int packvol,int* weight,int* value)//物品数，背包容量，重量数组，价值数组
{
	int packin[n];//记录物品的装入情况
	int w=0;//每次回溯过程中记录物品重量 
	int v=0;//物品价值
	int maxv=0;//最大价值 
	int k=0; 
	for(int i=0;i<n;i++)//初始化 
	{
		packin[i]=-1;
	}
	while(k>=0)
	{
		//packin[k]!=-1表示此种情况可能是经过回溯得到的，或者正在遍历 
		if(packin[k]!=-1)
		{
			w=w-weight[packin[k]];
			v=v-value[packin[k]];
			packin[k]=packin[k]+1;
		}
		//packin[k]==-1表示此种情况还未经过遍历 
		else
		{
			//这两个if else时为了减少时间复杂度
			//k！=0时可以直接在 packin[k-1]+1进行后面的遍历，因为背包中物品装入的顺序不会影响背包的价值。 
			if(k==0)
			{
				packin[k]=packin[k]+1;
			}
			else
				packin[k]=packin[k-1]+1;
		}
		//packin[k]表示物品编号,最大为n-1，当其值为n时表示当前情况已经全部遍历 
		if(packin[k]!=n)
		{
			w=w+weight[packin[k]];
			v=v+value[packin[k]];
		}
		//packin[k]所代表的物品是否额可以装入装入背包 
		while(packin[k]<n) 
		{
			if(check(packvol,w,k,packin)==true)
			{
				break;
			}
			else
			{
				w=w-weight[packin[k]];
				v=v-value[packin[k]];
				packin[k]=packin[k]+1;
				if(packin[k]!=n)
				{
					w=w+weight[packin[k]];
					v=v+value[packin[k]];
				}
			}
		}
		//三种情况 
		//满足剪枝条件，判断当前结果是否相对最优 
		//背包满了 
		if(packin[k]==n)
		{
			if(v>maxv)
			{
				maxv = v;
				print(packin,maxv,n);
			} 
			packin[k--]=-1;
		}
		//到达叶子节点，进行回溯 
		//背包不一定满但是物品装完了 
		else if(k==n-1) 
		{
			if(v>maxv)
			{
				maxv = v;
				print(packin,maxv,n);
			}
			w=w-weight[packin[k]];
			v=v-value[packin[k]];
			packin[k--]=-1;
		}
		//判断下一个节点 
		//背包没满物品也没装完 
		else if(k<n-1)
		{
			k=k+1;
		}
	}
}

 
void fwritein(int packvol,int n,int* weight,int* value)
{
	FILE* fp = fopen("demo4-1.TXT","w");
	fprintf(fp,"背包容量：%d\n",packvol);
	fprintf(fp,"物品数量：%d\n",n);
	for(int i=0;i<n;i++)
	{
		fprintf(fp,"%d\t%d\t%d\n",i,weight[i],value[i]);
	}
	fclose(fp);
}

void randomint(int packvol,int n,int* weight,int* value)
{
	for(int i=0;i<n;i++)
	{
		weight[i]=rand()%MAXW+1;
		value[i]=rand()%MAXV+1;
	}
	fwritein(packvol,n,weight,value);
	return;
}


int main()
{
	//输入背包问题所需数组信息 
	int n,packvol;
	srand(time(NULL));
	n = rand()%MAXN+1;
	packvol = rand()%MAX+1;
	int w[n],v[n];
	randomint(packvol,n,w,v);
	Pack(n,packvol,w,v);//01背包问题算法
	
	return 0;
}

二、TSP问题

【解题思路】
tsp问题：
1.输入图的结点个数和代价矩阵

2.回溯法依次处理结点

3.对于复杂性
【参考内容】
算法书《算法设计与分析第二版》158页中哈密顿回路问题的思路可以用来近似解决tsp问题
参考伪代码如下
回溯法tsp问题参考内容
伪代码第二点x[0]=1;个人认为改成x[0]=0;比较合适，下面代码中也是这么实现的
【代码分析】

TSP算法实现

//算法书158页解决哈密顿回路问题的伪代码可以近似看作解决tsp问题的来使用 
//下面的算法实现是依照书上的伪代码来写的 
void tsp(int* arc,int n)//参数：代价矩阵，结点数 
{
	int k;//k代表经过的顶点数，书上伪代码中没有提到但是代码中使用了 
	int x[n];//存储tsp路径上的顶点
	int visited[n];//存储顶点访问标志 
	int v=0;//tsp问题剪枝要使用到的权值 
	int minv=INF;//记录最小的权值情况 
	//算法书上默认从顶点0开始出发，所以下面也从顶点0开始出发
	//初始化
	for(int i=0;i<n;i++)
	{
		x[i]=0;
		visited[i]=0; 	
	}
	k=1;
	visited[0]=1;
	//伪代码这里写的x[0]=1;建议改正一下 
	x[0]=0;
	while(k>=1)
	{
		x[k]=x[k]+1;
		//若n个节点没有被穷举完 
		if(x[k]<n)
		{
			//若顶点x[k]不在tsp回路上，并且存在路径(x[k],x[k-1])
			//tsp问题是完全图所以一定存在这条路径，故这里省略一个判断 
			//判断权值是否比最小权值大，如果大那么一定不是最短路径直接跳过 
			//从x[k-1]节点到x[k]节点的代价 
			v=v+arc[(x[k-1])*n+x[k]];
			//if(visited[x[k]]==0 && v<minv)
			if(visited[x[k]]==0)
			{
				visited[x[k]]=1;
				//已经形成tsp路径
				if(k==n-1 && v+arc[x[k]*n+0]<minv)
				{
					minv=v+arc[x[k]*n+0];
					print(x,arc,n,0);
					v=v-arc[(x[k-1])*n+x[k]];
					visited[x[k]]=0;
					continue;
				}
				//构成tsp路径部分解 
				else if(v<minv)
				{
					k=k+1;
					continue;
				}
				//不能成为最短路径，直接跳过不处理 
				else
				{
					visited[x[k]]=0;
					v=v-arc[(x[k-1])*n+x[k]];
					continue;
				}
			}
			else//否则搜索下一个节点 
			{
				v=v-arc[(x[k-1])*n+x[k]];
				continue;
			}
		}
		//取消x[k]的访问标志，重置x[k]，k=k-1，
		else
		{
			v=v-arc[(x[k-2])*n+x[k-1]];
			visited[x[k-1]]=0;
			x[k]=0;
			k=k-1;
		}
	}
}

数据生成和输出和处理

生成和处理方式同实验二

生成数据

int main() { 
	int node;
	//自动生成方式
	//数据写入文件 
	FILE* fp = fopen("demo4-2.TXT","w");
	//生成随机数 
	srand((unsigned)time(NULL));
	node = MAXNODE;
	//生成数组矩阵，用一维数组表示二维数组 
	int *d = (int*)malloc(sizeof(int)*INF*INF);
	for(int i=0;i<node;i++)
	{
		for(int j=0;j<node;j++)
		{ 
			//行列相等默认最大值 
			if(j == i)
				d[i*node+j] = INF;
			else
				d[i*node+j] = rand()%MAX+1;
			fprintf(fp, "%d\t",d[i*node+j]);
			fprintf(fp, " ");
		}
		fprintf(fp, "\n");
	}
	//关闭文件 
	fclose(fp);
	//调用tsp函数 
   	tsp(d,node);
}

输出数据

void print(int* x,int* arc,int n,int start)//回路上的顶点数组，权值数值，最大节点，起点 
{
	int sum=0;
	printf("起点---代价---终点\n"); 
	for(int i=0;i<n;i++)
	{
		if(i==0)
		{
			printf("%-8d%-8d%-8d\n",start,arc[x[i]*n+x[i+1]],x[i+1]);
			sum+=arc[x[i]*n+x[i+1]];
		}
		else if(i==n-1)
		{
			printf("%-8d%-8d%-8d\n",x[i],arc[x[i]*n+x[0]],start);
			sum+=arc[x[i]*n+0];
		}
		else
		{
			printf("%-8d%-8d%-8d\n",x[i],arc[x[i]*n+x[i+1]],x[i+1]);
			sum+=arc[x[i]*n+x[i+1]];
		}
	}
	printf("总代价：%d\n\n",sum);
}

数据

回溯法tsp问题数据

输出

回溯法tsp问题输出

复杂度

回溯法tsp问题复杂度分析

TSP问题源代码

#include <stdio.h>
#include<malloc.h>
#include<time.h> 
#include<random>
#include<stdlib.h>

//宏定义区 
#define MAX 99//设置最大权值   
#define MAXNODE 7//节点数 
#define INF 9999//默认最大值 

//全局变量区

//函数声明区
void tsp(int*,int); 
void print(int*,int*,int,int);//回路上的顶点数组，权值数值，最大节点，起点 

int main() { 
	int node;
	//自动生成方式
	//数据写入文件 
	FILE* fp = fopen("demo4-2.TXT","w");
	//生成随机数 
	srand((unsigned)time(NULL));
	node = MAXNODE;
	//生成数组矩阵，用一维数组表示二维数组 
	int *d = (int*)malloc(sizeof(int)*INF*INF);
	for(int i=0;i<node;i++)
	{
		for(int j=0;j<node;j++)
		{ 
			//行列相等默认最大值 
			if(j == i)
				d[i*node+j] = INF;
			else
				d[i*node+j] = rand()%MAX+1;
			fprintf(fp, "%d\t",d[i*node+j]);
			fprintf(fp, " ");
		}
		fprintf(fp, "\n");
	}
	//关闭文件 
	fclose(fp);
	//调用tsp函数 
   	tsp(d,node);
}

void print(int* x,int* arc,int n,int start)//回路上的顶点数组，权值数值，最大节点，起点 
{
	int sum=0;
	printf("起点---代价---终点\n"); 
	for(int i=0;i<n;i++)
	{
		if(i==0)
		{
			printf("%-8d%-8d%-8d\n",start,arc[x[i]*n+x[i+1]],x[i+1]);
			sum+=arc[x[i]*n+x[i+1]];
		}
		else if(i==n-1)
		{
			printf("%-8d%-8d%-8d\n",x[i],arc[x[i]*n+x[0]],start);
			sum+=arc[x[i]*n+0];
		}
		else
		{
			printf("%-8d%-8d%-8d\n",x[i],arc[x[i]*n+x[i+1]],x[i+1]);
			sum+=arc[x[i]*n+x[i+1]];
		}
	}
	printf("总代价：%d\n\n",sum);
}

//算法书158页解决哈密顿回路问题的伪代码可以近似看作解决tsp问题的来使用 
//下面的算法实现是依照书上的伪代码来写的 
void tsp(int* arc,int n)//参数：代价矩阵，结点数 
{
	int k;//k代表经过的顶点数，书上伪代码中没有提到但是代码中使用了 
	int x[n];//存储tsp路径上的顶点
	int visited[n];//存储顶点访问标志 
	int v=0;//tsp问题剪枝要使用到的权值 
	int minv=INF;//记录最小的权值情况 
	//算法书上默认从顶点0开始出发，所以下面也从顶点0开始出发
	//初始化
	for(int i=0;i<n;i++)
	{
		x[i]=0;
		visited[i]=0; 	
	}
	k=1;
	visited[0]=1;
	//伪代码这里写的x[0]=1;建议改正一下 
	x[0]=0;
	while(k>=1)
	{
		x[k]=x[k]+1;
		//若n个节点没有被穷举完 
		if(x[k]<n)
		{
			//若顶点x[k]不在tsp回路上，并且存在路径(x[k],x[k-1])
			//tsp问题是完全图所以一定存在这条路径，故这里省略一个判断 
			//判断权值是否比最小权值大，如果大那么一定不是最短路径直接跳过 
			//从x[k-1]节点到x[k]节点的代价 
			v=v+arc[(x[k-1])*n+x[k]];
			//if(visited[x[k]]==0 && v<minv)
			if(visited[x[k]]==0)
			{
				visited[x[k]]=1;
				//已经形成tsp路径
				if(k==n-1 && v+arc[x[k]*n+0]<minv)
				{
					minv=v+arc[x[k]*n+0];
					print(x,arc,n,0);
					v=v-arc[(x[k-1])*n+x[k]];
					visited[x[k]]=0;
					continue;
				}
				//构成tsp路径部分解 
				else if(v<minv)
				{
					k=k+1;
					continue;
				}
				//不能成为最短路径，直接跳过不处理 
				else
				{
					visited[x[k]]=0;
					v=v-arc[(x[k-1])*n+x[k]];
					continue;
				}
			}
			else//否则搜索下一个节点 
			{
				v=v-arc[(x[k-1])*n+x[k]];
				continue;
			}
		}
		//取消x[k]的访问标志，重置x[k]，k=k-1，
		else
		{
			v=v-arc[(x[k-2])*n+x[k-1]];
			visited[x[k-1]]=0;
			x[k]=0;
			k=k-1;
		}
	}
}
一只想成为大佬的菜鸟
关注
  • 0
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
o-1背包问题迭代_算法设计：回溯法-解决01背包问题
weixin_39524984的博客
11-21 5298
一、算法思想 回溯法(探索与回溯法)是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法。有时会遇到这样一类题目，它的问题可以分解，但是又不能得出明确的动态规划或是递归解法，此时可以考虑用回溯法解决此类问题。回溯法的优点 再于其程序结构明确，可读性强，易于理解，而且通过对问题的分析...
算法设计与分析实验四：回溯法实现TSP问题和0-1背包问题
努力学习的小菜同学
08-04 5493
【实验目的】 1、掌握回溯法的设计思想； 2、掌握解空间树的构造方法，以及在求解过程中如何存储求解路径； 3、考察回溯法求解问题的有效程度。 TSP问题 一、实验内容： 利用回溯法编程求解TSP问题。 回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 　　用回溯算法解决问题的一般步骤为： 　1、定义一个解空间，它包含问题的解。 　2、利用适于搜索的方法组织解空间。 　3、利用深度优先法搜索解空间。 　4、利用剪枝函数避免移动到不可能产生解的子空间 对于n=4的TSP问题，其解空
基于回溯法求解0-1背包问题
m0_49071428的博客
01-06 2483
基于回溯法求解0-1背包问题
回溯算法求解01背包问题
f_1154652321的博客
10-19 2005
【算法】回溯算法求解01背包问题。
01 背包问题回溯法(JAVA)
JINX017的博客
02-20 919
01背包问题 回溯法 Java版
Java 使用回溯法解决01背包问题（含算法原理和代码）
最新发布
05-15
// 回溯法求解01背包问题 static int maxValue = 0; // 最大价值 static void knapsack(int capacity, List<Item> items, int currentIndex, int currentWeight, int currentValue) { // 如果当前索引超过了...
【算法分析】实验 4. 回溯法求解0-1背包等问题
weixin_30387663的博客
10-30 1636
目录 实验内容 实验目的 实验结果 步骤1：描述与分析 步骤2：策略以及数据结构 步骤3 步骤4 步骤5 步骤6 实验总结 实验内容 本实验要求基...
算法分析与设计：05 第五讲_回溯法.pdf
07-11
《算法分析与设计》第五讲的主题是回溯法，这是一种在面对复杂问题时，通过系统性的穷举搜索来寻找问题解的方法。回溯法尤其适用于那些解空间组合数巨大的问题，它遵循深度优先搜索策略，能够在解空间树中避免不必要...
利用回溯法解0-1背包问题讲解
04-27
利用回溯法解0-1背包问题是子集选取问题，0-1背包问题是NP难题，回溯法可以很好地解决背包问题，以期得到最优解。 回溯法概念： * 回溯法是一个既带有系统性又带有跳跃性的搜索算法。 * 它在包含问题的所有解的解...
剪枝函数-----0-1背包问题(c++)
weixin_43348682的博客
11-24 2216
#include <iostream> using namespace std; #define N 100 //默认有99个物品。第一个不使用 int w[N]; //每个物品的重量 int v[N]; //每个物品的价值 int n,c; //n：一共有多少物品，c：背包的最大容量 in...
算法设计与分析实验之背包问题
06-08
关于背包问题的源代码，包括贪心算法和动态算法
回溯法求解01背包问题
ScriptFlying的博客
12-19 5414
1.1 算法设计思想 用回溯法解决01背包问题，这实际是一个子集树问题： 首先对于背包中的物品按照单位重量价值进行排序，方便于后面子树的剪枝操作。 对于背包中的每一个物品，可以选择放入（左子树）或者不放入（右子树）。依次对每个节点进行搜索，得到最优解。 剪枝函数：对于左子树，如果放入物品的重量已经超出背包的容量，则直接进行剪枝。对于右子树，其判断取决于当前背包剩余的容量，依次取背包中剩余的...
回溯法求解TSP问题c++
无名小卒的博客
07-03 3220
回溯函数的模板为 void backtrack(int t) { if (t > n) output(x); else for (int i = t; i <= n; i++) { swap(x[t], x[i]); if (constraint(t) && bound(t)) //constraint(t)为约束函数，bound(t)为限界函数 backtrack(t + 1); swap(x[t], x[i]); } } 代码如下
基于回溯法和分支限界法求解01背包问题
lhd1110的博客
11-16 3850
基于回溯法和分支限界法求解01背包问题 问题描述 现有n个物品，1个背包。对物品i，其价值为viv_ivi​ ，重量为WiW_iWi​,背包的容量为WWW,如何选取物品使得背包里转入物品的总价值最大？ 在约束条件为：选取物品的重量小于等于背包重量的情况下，尽可能让背包中物品的总价值最大。 算法设计 01背包问题是自己选取问题，该问题的解空间可用子集树表明。设currentTotalValue是当前已经装入背包的物品的总价值、residueValue是剩余的未知是否装入物品的总价值，也就是未被搜索到物品的总价
回溯法求解TSP问题（C++）
weixin_47389461的博客
06-02 1780
回溯法求解TSP问题 TSP问题用回溯法求解 代码中的各个点的权值可以按需更改 输出会逐步给出搜索过程 #include <iostream> using namespace std; void clear(int *flag){ //清空flag表 for (int i = 0; i < 4; ++i) { flag[i] = 0; } } void calculate(int value[4][4]) { int length = 0; /
实验五 0-1背包问题的算法设计
enheihei的博客
02-05 869
本实验主要针对0-1背包的问题，采用不同种算法思想来解决。本实验介绍了四种方法，我主要采用了第一种动态规划和第二种贪婪算法来实现，提升了对该问题以及有关算法的了解程度。
算法设计与分析-TSP六种方法-贪心算法（最近邻点、最短链接）、蛮力法、动态规划法、回溯法、分支限界法、模拟退火
热门推荐
weixin_43794332的博客
09-03 3万+
旅行商问题，即TSP问题(Travelling Salesman Problem)又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。 一、贪心算法 贪心法求解TSP问题有两种贪心策略。 1）最近邻点策略：从任意城市出发，每次在没有到过的城市中选择最近的一个，直到经过了所有的城市，最后回到出发城市。 给定初始的城市a，寻找与
回溯法求解0-1背包问题
无名小卒的博客
07-03 1267
回溯函数的模板为 void backtrack(int t) { if (t > n) output(x); else for (int i = 0; i <= 1; i++) { x[t] = i; if (constraint(t) && bound(t)) //constraint(t)为约束函数，bound(t)为限界函数 backtrack(t + 1); } } 代码如下 #include <iostream> us
回溯法解决0-1背包问题(Java实现)
zhai1807307607的博客
05-23 1072
0-1背包问题就是给定背包容量、所有物品的重量和价值，问如何将物品装入背包，使得背包中的物品价值是最大的，每个物品只能整个整个的取，不能只取物品的一部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值