实验四回溯算法

合集下载

算法分析与设计实验报告--回溯法

算法分析与设计实验报告--回溯法实验目的：通过本次实验，掌握回溯法的基本原理和应用，能够设计出回溯法算法解决实际问题。

实验内容：1.回溯法概述回溯法全称“试探回溯法”，又称“逐步退化法”。

它是一种通过不断试图寻找问题的解，直到找到解或者穷尽所有可能的解空间技术。

回溯法的基本思路是从问题的某一个初始状态开始，搜索可行解步骤，一旦发现不满足求解条件的解就回溯到上一步，重新进行搜索，直到找到解或者所有可能的解空间已经搜索完毕。

2.回溯法的基本应用回溯法可用于求解许多 NP 问题，如 0/1 背包问题、八皇后问题、旅行商问题等。

它通常分为两种类型：一种是通过枚举所有可能的解空间来寻找解；另一种则是通过剪枝操作将搜索空间减少到若干种情况，大大减少了搜索时间。

3.回溯法的解题思路（1）问题分析：首先需要对问题进行分析，确定可行解空间和搜索策略；（2）状态表示：将问题的每一种状况表示成一个状态；（3）搜索策略：确定解空间的搜索顺序；（4）搜索过程：通过逐步试探，不断扩大搜索范围，更新当前状态；（5）终止条件：在搜索过程中，如果找到了满足要求的解，或者所有的可行解空间都已搜索完毕，就结束搜索。

4.八皇后问题八皇后问题是指在一个 8x8 的棋盘上放置八个皇后，使得任意两个皇后都不在同一行、同一列或同一对角线上。

通过回溯法可以求解出所有的可能解。

实验过程：回溯法的实现关键在于搜索空间的剪枝，避免搜索无用的解；因此，对于八皇后问题，需要建立一个二维数组来存放棋盘状态，以及一个一维数组来存放每行放置的皇后位置。

从第一行开始搜索，按照列的顺序依次判断当前的空位是否可以放置皇后，如果可以，则在相应的位置标记皇后，并递归到下一行；如果不能，则回溯到上一行，重新搜索。

当搜索到第八行时，获取一组解并返回。

代码实现：```pythondef is_valid(board, row, col):for i in range(row):if board[i] == col or abs(board[i] - col) == abs(i - row):return Falsereturn True实验结果：当 n=4 时，求得的所有可行解如下：```[[1, 3, 0, 2],[2, 0, 3, 1]]```本次实验通过实现回溯法求解八皇后问题，掌握了回溯法的基本原理和应用，并对回溯法的核心思想进行了深入理解。

实验报告4.回溯算法

算法设计与分析实验报告实验名称_____回溯算法_____学院________数学与计算机学院____ 班级_______信科00000___________ 学号_______6666666666__________ 姓名_____000000________________ 2016年月日{if(((a+b)==24)||((a-b)==24)||((a*b)==24)||(b!=0&&a%b==0&&a/b==24)){//如果经过上面的计算得到解while(!route.empty()){node now=route.front();printf("%d%c%d=%d\n",now.a,now.oper,now.b,now.sum);//依次输出前面的计算过程route.pop();}if((a+b)==24){if(b>a) swap(a,b);printf("%d+%d=%d\n",a,b,a+b);}if((a-b)==24) printf("%d-%d=%d\n",a,b,a-b);if((a*b)==24) {if(b>a) swap(a,b);printf("%d*%d=%d\n",a,b,a*b);}if(a%b==0&&b!=0&&(a/b)==24) printf("%d/%d=%d\n",a,b,a/b);//a/b比较特殊，要求结果必须是整数flag=true;//表示找到解，一旦找到任何一个解就退出}return ;}queue <node> temp=route;node x;x.a=a,x.b=b,x.sum=a+b,x.oper='+';if(b>a) swap(x.a,x.b);temp.push(x);dfs(cur+1,a+b,num[cur+1],temp);//(((a*b)*c)*d) 模型temp=route;x.a=a,x.b=b,x.sum=a*b,x.oper='*';if(b>a) swap(x.a,x.b);temp.push(x);dfs(cur+1,a*b,num[cur+1],temp);temp=route;x.a=a,x.b=b,x.sum=a-b,x.oper='-';temp.push(x);dfs(cur+1,a-b,num[cur+1],temp);if(b!=0&&a%b==0){//a/b需要验证合法性temp=route;x.a=a,x.b=b,x.sum=a/b,x.oper='/';temp.push(x);dfs(cur+1,a/b,num[cur+1],temp);}temp=route;x.a=b,x.b=num[cur+1],x.sum=b+num[cur+1],x.oper='+';if(x.b>x.a) swap(x.a,x.b);temp.push(x);dfs(cur+1,a,b+num[cur+1],temp);//a*((b*c)*d) 模型temp=route;x.a=b,x.b=num[cur+1],x.sum=b*num[cur+1],x.oper='*';if(x.b>x.a) swap(x.a,x.b);temp.push(x);dfs(cur+1,a,b*num[cur+1],temp);temp=route;x.a=b,x.b=num[cur+1],x.sum=b-num[cur+1],x.oper='-';temp.push(x);dfs(cur+1,a,b-num[cur+1],temp);if(num[cur+1]!=0&&b%num[cur+1]==0) {temp=route;x.a=b,x.b=num[cur+1],x.sum=b/num[cur+1],x.oper='/';temp.push(x);dfs(cur+1,a,b/num[cur+1],temp);}}int main(){//freopen("point24.in","r",stdin);//输入输出重定向//freopen("point24.out","w",stdout);queue <node> t;scanf("%d %d %d %d",&num[0],&num[1],&num[2],&num[3]);while(!flag){dfs(1,num[0],num[1],t);printf("%d %d %d %d\n",num[0],num[1],num[2],num[3]);if(!next_permutation(num,num+4)) break;}if(!flag) printf("No answer!\n");system("pause");return 0;}。

实验四回溯法(图着色问题)

对应的邻接矩阵
01 234 001 1 01 1 1 01 01 21 1 01 0 3001 01 41 1 01 0
class MGraph { public:
MGraph(int v,int s); void mColoring(int m,int *x); //一维数组x，存放1~n个顶点的颜色 ~MGraph(); private: void NextValue(int k,int m,int *x); void mColoring (int k,int m,int *x); int **a; //二维数组a，存储图的邻接矩阵 int n,e; //n表示图的顶点数，e表示边数 };
无向图G
【实验内容与要求】
图的着色问题：设G=(V,E)是一连通无向图，有3 种颜色，用这些颜色为G的各顶点着色，每个顶点着一种颜色，且相邻顶点颜色不同。试用回溯法设计一个算法，找出所有可能满足上述条件的着色法。
无向图G
无向图G
对应这个无向图的状态空间树应该是怎样的？
是一个完全3叉树，共6层
实验四回溯法 — 图的着色问题
图的着色问题是由地图的着色问题引申而来的：用m种颜色为地图着色，使得地图上的每一个区域着一种颜色，且相邻区域颜色不同。
问题处理：如果把每一个区域收缩为一个顶点，把相邻两个区域用一条边相连接，就可以把一
个区域图抽象为一个平面图。
地图（map）中地区的相邻关系，在图（graph ）中用边表示。
//若(i, j)是图的边，且相邻结点k和j颜色相同 //发生冲突，选下一种颜色
if (j==k) return; //成功选择一种颜色返回 }while (1); //循环尝试颜色 }
运行结果：

回溯与分支限界算法设计

算法设计与分析实验报告1.骑士游历问题（采用回溯法）：在国际象棋的棋盘（8行×8列）上放置一个马，按照“马走日字”的规则，马要遍历棋盘，即到达棋盘上的每一格，并且每格只到达一次。

若给定起始位置（x0,y0）,编程探索出一条路径，沿着这条路径马能遍历棋盘上的所有单元格。

2. 行列变换问题（采用分支限界法）：给定两个m n方格阵列组成的图形A和图形B，每个方格的颜色为黑色或白色，如下图所示。

行列变换问题的每一步变换可以交换任意2行或2列方格的颜色，或者将某行或某列颠倒。

上述每次变换算作一步。

试设计一个算法，计算最少需要多少步，才能将图形A变换为图形B。

图形A图形B}}实例：2. 行列变换问题的程序：package ;import graph{static int sour, dest;//sour是图形的初始整数，dest是图形的目的整数static int ans[]=new int[1<<16];//静态变量（即全局变量），用于存放图形变换的路径int m=4,n=4,x;int row[]=new int[4];int col[]=new int[4];void setx(int x){=x;}int getx(){return ;}x/=2;}}}public static void output(int N){if(N=={outb(N);return;}output[N]);//[N]存放着从初始值到目的值的遍历路径outb(N);}}实例：实验成绩：指导教师：年月日精心搜集整理，。

回溯算法实验 - 频道分配问题

} int main() { char ch[27]; while(cin>>lines&&lines)
{ int step = 1; m = 5; memset(set,0,sizeof(set)); memset(result,0,sizeof(result)); for(int i=0;i<lines;i++) { cin>>ch; for(int j=2;ch[j]!='\0';j++) set[i][ch[j]-'A']=1; } result[0] = 1; backtrack(1); if(m==1) cout<<m<<" channel needed."<<endl; else cout<<m<<" channels needed."<<endl; } return 0;
3、分析出算法复杂度图 m 可着色问题的回溯算法的计算时间上界可以通过计算解空间树中内结点个数来估计。图 m 可着色问题的解空间树中内结点个数是 m i 。对于每一个
i n 1
内结点，在最坏情况下，用 same 检查当前扩展结点的每一个儿子所相应的颜色的可用性需耗时 O(m n) 。因此，回溯法总的时间耗费是
四、实验内容
1 、登陆 POJ 系统，找到题号为 1129 的题目 - 频道分配； 2、阅读题目，分析出求解该问题的思路； 3、使用回溯算法，实现本题； 4 、进行简单测试，完成之后提交到 POJ 系统。

回溯算法实验报告

回溯算法实验报告实验目的：回溯算法是一种递归算法，通常用于解决有限集合的组合问题。

本实验旨在通过实现回溯算法来解决一个具体的问题，并对算法的性能进行评估。

实验内容：本实验将以八皇后问题为例，展示回溯算法的应用。

八皇后问题是一个经典的问题，要求在一个8x8的棋盘上放置8个皇后，使得任意两个皇后不能在同一行、同一列或同一对角线上。

算法步骤：1. 创建一个二维数组，表示棋盘。

初始化所有元素为0，表示棋盘上无皇后。

2. 逐行进行操作，尝试在每一列放置皇后。

在每一列，从上到下逐个位置进行尝试，找到一个合适的位置放置皇后。

3. 如果找到合适的位置，则将该位置标记为1，并向下一行进行递归操作。

4. 如果当前位置无法放置皇后，则回溯到上一行，尝试放置皇后的下一个位置。

5. 当所有皇后都放置好后，得到一个解。

将该解加入结果集中。

6. 继续回溯，尝试寻找下一个解。

7. 当所有解都找到后，算法终止。

实验结果：在本实验中，我们实现了八皇后问题的回溯算法，并进行了性能测试。

根据实验结果可以看出，回溯算法在解决八皇后问题上表现出较好的性能。

实验中，我们使用的是普通的回溯算法，没有进行优化。

对于八皇后问题来说，回溯算法可以找到所有解，但是随着问题规模的增加，算法的执行时间也会大大增加。

回溯算法是一种非常灵活的算法，可以用于解决各种组合问题。

对于规模较大的问题，回溯算法的时间复杂度很高，需要考虑优化算法以提高性能。

在实际应用中，可以结合其他算法，如剪枝等技巧，来改进回溯算法的性能。

回溯算法是一种非常有价值的算法，值得进一步研究和应用。

实验4 回溯算法

《算法设计与分析》实验报告实验4 回溯算法一、实验目的：掌握回溯算法的设计思想与设计方法。

二、实验环境1、硬件环境CPU：Intel(R) Celeron(R) CPU 1007U @ 1.5GHz内存：4G硬盘：500G2、软件环境操作系统：Windows7编程环境：Visual C++ 6.0编程语言：C三、实验内容1、问题有一个背包，最大限重为C，有n个物品，重量分别为W=<w1, w2, …, w n>，要求找出一个装载方案，使得放入背包物品的重量最大。

输出装载方案和该方案下的背包所装物品总重量。

2、数据结构（1）解的结构一维数据（1）<0 1 0 1 1 1 1>(2) <0 0 1 0 1 1 0>（2）搜索空间的结构3、算法伪代码ReBack(i)1、If i>n then<x1,x2,x3,...xn>是解2、Else while Si≠∅do3、Xi Si中最小值4、SiＳｉ－｛Ｘｉ｝５计算Ｓｉ＋１６ReBack（ｉ＋１)4、算法分析时间复杂度：O(2n)空间复杂度：O(n)5、关键代码（含注释）#include<stdio.h>int n,c,bestp;//物品的个数，背包的容量，最大重量int w[10000],x[10000],bestx[10000];//w[i]物品的重量，x[i]暂存物品的选中情况,bestx[i]物品的选中情况void Backtrack(int i,int cw){ //cw当前包内物品重量int j;if(i>n)//回溯结束{if(cw>bestp){bestp=cw;for(i=0;i<=n;i++) bestx[i]=x[i];}}elsefor(j=0;j<=1;j++){x[i]=j;if(cw+x[i]*w[i]<=c){cw+=w[i]*x[i];Backtrack(i+1,cw);cw-=w[i]*x[i];}}}6、实验结果（1）输入：C=152，n=7，W=<90, 80, 40, 30, 20, 12, 10> 输出：（2）输入：C=954，n=7，W=<2, 23, 163, 241, 311, 479, 487> 输出：四、实验总结（心得体会、需要注意的问题等）回溯算法也称试探法，是一种系统的搜索问题的解的方法。

实验四回溯法的应用------跳马算法

实验四回溯法的应用------跳马算法学号：012124345 姓名：梁文耀一、实验目的掌握使用回溯法求解问题的基本思路；理解其特点。

二、实验思想算法的基本思路是：定义结构体：struct PLACE{int x, int y}表示棋盘上的位置。

依题意，马每跳一步之后都可以从七个不同的方向选择下一步的跳马，当然，前提是跳的这一步在棋盘内且它前面的任何一步都没跳到这一格子上（限界），就可以认为这一步跳成功，否则跳马不成功。

若跳马不成功，则找下一个方向尝试跳马，若七个方向都跳马不成功，则回溯。

假设棋盘的行（列）数为n。

在本算法中设置这样一个全局数组：c[8][2]={{2,1},{2,-1},{1,2},{1,-2},{-2,1},{-2,-1},{-1,2},{-1,-2}}; 来记录跳马的八个方向。

三、程序分析（主要算法）int map[12][12], status[12][12], kp;int start,finsh;int c[8][2]={{2,1},{2,-1},{1,2},{1,-2},{-2,1},{-2,-1},{-1,2},{-1,-2}};int flag = 0;void prt(int a[][12]) /* 打印棋盘状态*/{int i,j;printf("\n");for (i=2;i<=9;i++){for (j=2;j<=9;j++)printf("%4d",a[i][j]);printf("\n");}}void status2(void) /* 计算棋盘各点条件数*/ {int i,j,k,i2,j2,kz;for(i=0;i<12;i++)for(j=0;j<12;j++)status[i][j]=100;for(i=2;i<=9;i++)for(j=2;j<=9;j++){kz=0;for (k=0;k<=7;k++){i2=i+c[k][0];j2=j+c[k][1];if (map[i2][j2]<50) kz++;}status[i][j]=kz;}//prt(status);}void sort1(int b1[],int b2[]) /* 对8个可能的方向按条件数排序*/ {int i,j,mini,t; /*b1[]记录状态值（升序），b2[]记录排序后的下标*/ for (i=0;i<=7;i++){mini=i;for (j=i+1;j<=7;j++)if (b1[j]<b1[mini]) mini=j;t=b1[i]; b1[i]=b1[mini]; b1[mini]=t;t=b2[i]; b2[i]=b2[mini]; b2[mini]=t;}}void init1(void) /* 初始化*/{int i,j;for(i=0;i<12;i++)for(j=0;j<12;j++)map[i][j]=100;for(i=2;i<=9;i++)for(j=2;j<=9;j++)map[i][j]=0;status2();}void search(int i2,int j2) /* 利用递归回溯进行搜索*/ {if (flag == 1)return ;int b1[8],b2[8],i,i3,j3;kp++;for(i=0;i<=7;i++)//8个方向{b2[i]=i;b1[i]=status[i2+c[i][0]][j2+c[i][1]];}//forsort1(b1,b2);for(i=0;i<=7;i++)//检查是否可以走{i3=i2+c[b2[i]][0]; //按照排序中的方向查找j3=j2+c[b2[i]][1];if (map[i3][j3]==1 && kp==65){prt(map);flag = 1;}if (map[i3][j3]==0)//若有路可以走，则执行下面操作{map[i3][j3]=kp;search(i3,j3); //递归调用map[i3][j3]=0; //若还没有走完并且已经没有路走则恢复0状态}//if}//forkp--;//回朔}//searchint main(){int row, column;char ch;//int start,finsh;while (true){//打印提示信息cout<<" 1: 开始程序"<<endl;cout<<" 2: 退出程序"<<endl;cout<<"注意："<<endl;cout<<""<<endl;cout<<"输入选择(1 或2):"<<endl;//如果输入信息不正确，继续输入do{ch = (char)_getch();}while(ch != '1' && ch != '2');system("cls");//选择3，返回if (ch == '2'){cout<<"退出!!!"<<endl;return 0;}//选择1,进入操作程序else{init1();cout<<"输入初始位置(行row)(1<=row<=8)："<<endl;cin>>row;row = row + 1;cout<<"输入初始位置(列column)(1<=column<=8)："<<endl;cin>>column;column = column + 1;map[row][column] = 1;kp = 1;start = clock();cout<<"遍历结果："<<endl;search(row,column);flag = 0;finsh = clock();cout<<"算法运行时间："<<finsh-start<<endl;kp = 1;}//结束cout<<endl<<"Press Any Key To Contimue:"<<endl;_getch();system("cls");}//whilereturn 0;}四、心得体会这程序和以前做的迷宫问题很相象，写起来不是很困难. 确定限界函数，在只有满足限界函数的前提下得到解，不满足限界条件时就要回溯，回到上一个节点，再从另外的方向出发。

回溯算法实验报告(一)

回溯算法实验报告(一)回溯算法实验报告1. 简介回溯算法是一种经典的解决问题的方法，特别适用于求解排列组合问题、迷宫问题以及图的搜索等。

本实验旨在探究回溯算法的原理、应用以及优缺点。

2. 原理回溯算法是一种递归的算法，通过不断试错来找出问题的解。

其基本思想是： - 从问题给定的初始解开始，逐步构建一个候选解； - 当候选解不满足约束条件时，进行回溯，返回上一步重新构建候选解；- 当所有候选解都被尝试过且都不满足约束条件时，算法停止。

3. 应用回溯算法在很多领域都有广泛的应用，以下列举几个常见的例子：1. 排列组合问题：如求解一个数组的全排列； 2. 迷宫问题：如求解从起点到终点的路径； 3. 图的搜索：如深度优先搜索（DFS）和广度优先搜索（BFS）。

4. 优缺点回溯算法有以下优点： - 适用性广：可以解决多种问题，特别擅长于求解排列组合和搜索类问题； - 简单直观：算法思想直观，易于理解和实现。

但回溯算法也有一些缺点： - 效率较低：因为回溯算法需要枚举所有可能的解，所以在问题规模较大时，时间复杂度较高； - 可能存在重复计算：如果问题的解空间中存在重复的子问题，回溯算法可能会进行重复的计算。

5. 实验结论通过本实验我们可以得出以下结论： 1. 回溯算法是一种经典的解决问题的方法，可应用于多个领域； 2. 回溯算法的基本原理是试错法，通过逐步构建候选解并根据约束条件进行回溯，找到问题的解；3. 回溯算法的优点是适用性广、简单直观，但缺点是效率较低且可能存在重复计算。

因此，在实际应用中，我们需要根据具体问题的特点来选择适合的算法。

回溯算法在问题规模较小时可以快速得到解答，但对于规模较大的问题，可能需要考虑其他高效的算法。

6. 探索进一步改进回溯算法的方法虽然回溯算法在解决一些问题时非常有用，但对于问题规模较大的情况，它可能会变得低效且耗时。

因此，我们可以探索一些方法来改进回溯算法的性能。

6.1 剪枝策略在回溯算法中，我们可以通过剪枝策略来减少无效的搜索路径，从而提高算法的效率。

算法实验四回溯法

n=nn;
sum=0;
x=newint[n+1];
//尝试第一行的所有位置
for(inti=0;i<=n;i++)
x[i]=0;
backtrack(1);
returnsum;
}
privatestaticvoidbacktrack(intt) {
if(t>n)sum++;
else
for(inti=1;i<=n;i++){//从第一行开始往下放置，放置陈功继续
xi @{0,1},1<=i<=n
用回溯法解装载问题时，用子集树表示其解空间显然是最合适的。可行性约束函数可剪去不满足约束条件（
(w1x1+w2x2+...+wixi)<= c1）的子树。在子集树的第j+1层的节点Z处，用cw记当前的装载重量，即cw=(w1x1+w2x2+...+wjxj)，当cw>c1时，以节点Z为根的子树中所有节点都不满足约束条件，因而该子树中解均为不可行解，故可将该子树剪去。
【算法描述】
importjava.util.Scanner;
publicclassNQueen {
staticintn;//皇后个数
staticintx[];//当前解，表示x[i]表示第i行皇后位置
staticlongsum;//当前已找到的可行方案数
publicstaticvoidmain(String[] args) {
1.首先将第一艘轮船尽可能装满。
2.将剩余的集装箱装上第二艘轮船。
将第一艘轮船尽可能的装满等价于选取全体集装箱的子集，使该子集中集装箱的重量之和最接近c1。因此，等价于一个特殊的0-1背包问题。因此是一棵子集树。

《回溯法实验》实验报告

实验4、《回溯法实验》一、实验目的1. 掌握回溯算法思想2. 掌握回溯递归原理3. 了解回溯法典型问题二、实验内容1. 编写一个简单的程序，解决8皇后问题。

2. 批处理作业调度问题[问题描述]给定n个作业的集合J=(J1, J2, … , Jn)。

每一个作业Ji都有两项任务需要分别在2台机器上完成。

每一个作业必须先由机器1处理，然后再由机器2处理。

作业Ji需要机器i的处理时间为tji，i=1,2, … ,n; j=1,2。

对于一个确定的作业调度，设Fji是作业i在机器i上完成处理的时间。

则所有作业在机器2上完成处理的时间和成为该作业调度的完成时间和。

批处理作业调度问题要求对于给定的n个作业，制定一个最佳的作业调度方案，使其完成时间和达到最小。

要求输入：1）作业数 2）每个作业完成时间表：作业完成时间机器1 机器2作业1 2 1作业2 3 1作业3 2 3要求输出： 1）最佳完成时间 2）最佳调度方案提示：算法复杂度为O(n!),建议在测试的时候n值不要太大，可以考虑不要超过12。

3. 数字全排列问题任意给出从1到N的N个连续的自然数，求出这N个自然数的各种全排列。

如N=3时，共有以下6种排列方式：123，132，213，231，312，321。

注意：数字不能重复，N由键盘输入（N<=9）。

三、算法思想分析1.八皇后问题是典型的回溯问题，先从空格子起逐行放皇后，如果符合要求即安全则放置，否则返回上一行下一个位置继续，直至最后一行安全放置则为一种放置方式。

2.批处理作业调度的解空间为排列数，不断利用递归函数直至叶节点，剪枝函数为当前用时与最佳用时的比较。

关于时间的计算，每次选择作业后先将机器1用时累加，机器2上总用时需要先比较上一个作业完成时间与此时机器1上的总用时，如果机器1上总用时大于上一作业用时，那么机器2上用时则加上机器1上用时与此作业在机器2上的单独用时，反之，则代表此时机器2仍然在处理上一任务，那么机器2上用时则加上上一作业用时与此作业在机器2上的单独用时。

回溯法

算法实验报告四回溯法实验一、实验目的及要求利用回溯方法设计指派问题的算法，掌握回溯法的基本思想和算法设计的基本步骤。

要求：设计指派问题的回溯算法，注意回溯算法解决此问题要找出问题所有的可行解，然后一次比较保留问题的最优解(即最少耗费的解)，并输出结果。

利用c语言（c++语言）实现算法，给出程序的正确运行结果。

（必须完成）指派问题描述：n个雇员被指派做n件工作，使得指派第i个人做第i件工作的耗费为ci,j,找出一种指派使得总耗费最少。

二、算法描述输入一个二维矩阵如下：352 4675 3374 5854 6其中行代表第几个雇员，列代表第几项工作，利用非递归的回溯算法实现，有主函数中定义k为第几个雇员，k的取值为集合｛1,2，3,4｝中元素。

且为行，列用a[k]表示，表示第几项工作。

定义耗费数组,一般项为c[i][j]]，则c[k][a[k]]就可表示第k个人做第a[k]个工作。

由于同一个工作不能被两个人做或者说每个人只能做不同的工作，因此若设行排列固定，则a[k]!=a[j]，其中从j=1变到=k-1即第k个人只能做1项的工作。

即他在做第a[k]项工作时要保证前面的工作都没做。

开始：For k =1 to 4a[k]=0;end for;k=1;while k>=1while a[k]<=3a[k]=a[k]+1;v=v+c[k][a[k]];for(j=1;j<=k-1;j++)if(a[k]!=a[j])标记合法与部分解；else标记非法解，剪掉部分；If a[k]为合法解then 输出当前指派和当前最小耗费Else if a[k]为部分解then k=k+1｛前进｝End while;a[k]=0;k=k-1;v=v-c[k][a[k]];｛回溯｝End while;输出每次求得的耗费，求出最小的即调用min(s[])函数，并将最小耗费cost输出;结束三、调试过程及运行结果调试过程中出现的问题：虽然按照回溯算法所给的模式写完了程序，却不对，经单步调试发现是我的程序结构混乱，部分解和合法解还有非法解之间的条件处理那有问题，因为通过一个循环要保证一个人只能做一项工作，而且要做别人没做过的工作，此条件对于部分解、合法解都要求，而当它不满足时应跳出作另外处理。

算法之回溯法实现

实验4 回溯法实现一、实验目标：1.熟悉回溯法应用场景及实现的基本方法步骤；2.学会回溯法的实现方法和分析方法：二、实验内容1. 旅行售货员问题：当结点数为4，权重矩阵为，求最优路径及开销。

2. 0-1背包问题：对于n=5，C=10，vi={6,3,5,4,6}，wi={2,2，6,5,4}，计算xi及最优价值V。

分别利用动态规划、回溯法和分支限界法解决此问题，比较并分析这三种算法实现！三、实验过程1.源代码旅行售货员问题（回溯法）：#include<iostream>using namespace std;class travel //回溯{friend int TSP(int **, int[], int, int);void Backtrack(int i);int n, //顶点数*x,*bestx;int **a,cc,bestc,NoEdge;};void Swap(int a, int b){int temp;temp = a;a = b;b = temp;return;}void travel::Backtrack(int i){if (i == n){if (a[x[n - 1]][x[n]] != NoEdge && a[x[n]][1] != NoEdge &&(cc + a[x[n - 1]][x[n]] + a[x[n]][1]) < bestc || bestc == NoEdge)for (int j = 1; j <= n; j++) bestx[j] = x[j];bestc = cc + a[x[n - 1]][x[n]] + a[x[n]][1];}}else{for (int j = i; j <= n; j++){if (a[x[i - 1]][j] != NoEdge && a[x[n]][1] != NoEdge&& (cc + a[x[i - 1]][x[j]] < bestc || bestc == NoEdge)) {swap(x[i], x[j]);cc += a[x[i - 1]][x[i]];Backtrack(i + 1);cc -= a[x[i - 1]][x[i]];swap(x[i], x[j]);}}}}int TSP(int** a,int v[], int n, int NoEdge){travel Y;Y.x = new int[n + 1];for (int i = 1; i <= n; i++)Y.x[i] = i;Y.a = a;Y.n = n;Y.bestc = NoEdge;Y.bestx = v; = 0;Y.NoEdge = NoEdge;Y.Backtrack(2);delete[] Y.x;return Y.bestc;}int main(){int const max = 10000;cout << "请输入节点数:" << endl;int n;cin >> n;int *v = new int[n];//保存路径int NoEdge = 0;int **p = new int*[max];for (int i = 0; i < n+1; i++)//生成二维数组p[i] = new int[n+1];cout << "请依次输入各城市之间的路程：" << endl;for (int i = 0; i < n; i++)for (int j = 0; j < n; j++)cin >> p[i+1][j+1];cout << "最短路径长度：" << TSP(p, v, 4, 1000) << endl;cout << "路径为：";for (int i = 1; i < 5; i++)cout << v[i] <<' ';cout << endl;return 0;}运行截图：旅行售货员问题（分支限界法）：#include<iostream>using namespace std;#define MAX_CITY_NUMBER 10 //城市最大数目#define MAX_COST 1000 //两个城市之间费用的最大值int City_Graph[MAX_CITY_NUMBER][MAX_CITY_NUMBER];//表示城市间边权重的数组int City_Size; //表示实际输入的城市数目int Best_Cost; //最小费用int Best_Cost_Path[MAX_CITY_NUMBER];//结点typedef struct Node {int lcost; //优先级int cc; //当前费用int rcost; //剩余所有结点的最小出边费用的和int s; //当前结点的深度，也就是它在解数组中的索引位置int x[MAX_CITY_NUMBER]; //当前结点对应的路径struct Node* pNext; //指向下一个结点}Node;//堆typedef struct MiniHeap {Node* pHead; //堆的头}MiniHeap;//初始化void InitMiniHeap(MiniHeap* pMiniHeap) {pMiniHeap->pHead = new Node;pMiniHeap->pHead->pNext = NULL;}//入堆void put(MiniHeap* pMiniHeap, Node node) {Node* next;Node* pre;Node* pinnode = new Node; //将传进来的结点信息copy一份保存//这样在函数外部对node的修改就不会影响到堆了pinnode->cc = ;pinnode->lcost = node.lcost;pinnode->pNext = node.pNext;pinnode->rcost = node.rcost;pinnode->s = node.s;pinnode->pNext = NULL;for (int k = 0; k<City_Size; k++) {pinnode->x[k] = node.x[k];}pre = pMiniHeap->pHead;next = pMiniHeap->pHead->pNext;if (next == NULL) {pMiniHeap->pHead->pNext = pinnode;}else {while (next != NULL) {if ((next->lcost) >(pinnode->lcost)) { //发现一个优先级大的，则置于其前面pinnode->pNext = pre->pNext;pre->pNext = pinnode;break; //跳出}pre = next;next = next->pNext;}pre->pNext = pinnode; //放在末尾}}//出堆Node* RemoveMiniHeap(MiniHeap* pMiniHeap) {Node* pnode = NULL;if (pMiniHeap->pHead->pNext != NULL) {pnode = pMiniHeap->pHead->pNext;pMiniHeap->pHead->pNext = pMiniHeap->pHead->pNext->pNext;}return pnode;}//分支限界法找最优解void Traveler() {int i, j;int temp_x[MAX_CITY_NUMBER];Node* pNode = NULL;int miniSum; //所有结点最小出边的费用和int miniOut[MAX_CITY_NUMBER];//保存每个结点的最小出边的索引MiniHeap* heap = new MiniHeap; //分配堆InitMiniHeap(heap); //初始化堆miniSum = 0;for (i = 0; i<City_Size; i++) {miniOut[i] = MAX_COST; //初始化时每一个结点都不可达for (j = 0; j<City_Size; j++) {if (City_Graph[i][j]>0 && City_Graph[i][j]<miniOut[i]) {//从i到j可达，且更小miniOut[i] = City_Graph[i][j];}}if (miniOut[i] == MAX_COST) {// i 城市没有出边Best_Cost = -1;return;}miniSum += miniOut[i];}for (i = 0; i<City_Size; i++) { //初始化的最优路径就是把所有结点依次走一遍Best_Cost_Path[i] = i;}Best_Cost = MAX_COST; //初始化的最优费用是一个很大的数pNode = new Node; //初始化第一个结点并入堆pNode->lcost = 0; //当前结点的优先权为0 也就是最优pNode->cc = 0; //当前费用为0（还没有开始旅行）pNode->rcost = miniSum; //剩余所有结点的最小出边费用和就是初始化的miniSumpNode->s = 0; //层次为0pNode->pNext = NULL;for (int k = 0; k<City_Size; k++) {pNode->x[k] = Best_Cost_Path[k]; //第一个结点所保存的路径也就是初始化的路径}put(heap, *pNode); //入堆while (pNode != NULL && (pNode->s) < City_Size - 1) {//堆不空不是叶子for (int k = 0; k<City_Size; k++) {Best_Cost_Path[k] = pNode->x[k]; //将最优路径置换为当前结点本身所保存的}/** * pNode 结点保存的路径中的含有这条路径上所有结点的索引* * x路径中保存的这一层结点的编号就是x[City_Size-2]* * 下一层结点的编号就是x[City_Size-1]*/if ((pNode->s) == City_Size - 2) { //是叶子的父亲int edge1 = City_Graph[(pNode->x)[City_Size -2]][(pNode->x)[City_Size - 1]];int edge2 = City_Graph[(pNode->x)[City_Size - 1]][(pNode->x)[0]];if (edge1 >= 0 && edge2 >= 0 && (pNode->cc + edge1 + edge2) < Best_Cost) {//edge1 -1 表示不可达//叶子可达起点费用更低Best_Cost = pNode->cc + edge1 + edge2;pNode->cc = Best_Cost;pNode->lcost = Best_Cost; //优先权为 Best_CostpNode->s++; //到达叶子层}}else {//内部结点for (i = pNode->s; i<City_Size; i++){ //从当前层到叶子层if (City_Graph[pNode->x[pNode->s]][pNode->x[i]] >= 0) { //可达//pNode的层数就是它在最优路径中的位置int temp_cc = pNode->cc +City_Graph[pNode->x[pNode->s]][pNode->x[i]];int temp_rcost = pNode->rcost - miniOut[pNode->x[pNode->s]];//下一个结点的剩余最小出边费用和//等于当前结点的rcost减去当前这个结点的最小出边费用if (temp_cc + temp_rcost<Best_Cost) { //下一个结点的最小出边费用和小于当前的最优解，说明可能存在更优解for (j = 0; j<City_Size; j++) { //完全copy路径，以便下面修改temp_x[j] = Best_Cost_Path[j];}temp_x[pNode->x[pNode->s + 1]] = Best_Cost_Path[i];//将当前结点的编号放入路径的深度为s+1的地方temp_x[i] = Best_Cost_Path[pNode->s + 1];//将原路//径中的深度为s+1的结点编号放入当前路径的//相当于将原路径中的的深度为i的结点与深度W为s+1的结点交换Node* pNextNode = new Node;pNextNode->cc = temp_cc;pNextNode->lcost = temp_cc + temp_rcost;pNextNode->rcost = temp_rcost;pNextNode->s = pNode->s + 1;pNextNode->pNext = NULL;for (int k = 0; k<City_Size; k++) {pNextNode->x[k] = temp_x[k];}put(heap, *pNextNode);delete pNextNode;}}}}pNode = RemoveMiniHeap(heap);}for (int k = 0; k<City_Size; k++) {//复制路径Best_Cost_Path[k] = temp_x[k];}}int main() {cout << "请输入节点数：" << endl;cin >> City_Size;cout << "请依次输入各城市之间的距离" << endl;for (int i = 0; i < City_Size; i++)for (int j = 0; j < City_Size; j++){cin >> City_Graph[i][j];if (City_Graph[i][j] == 0)City_Graph[i][j] = 1000;}Traveler();cout <<"最短路径长度：" <<Best_Cost << endl;cout << "路径为：";for (int i = 0; i < 4; i++)cout << Best_Cost_Path[i]+1 << ' ';return 0;}运行截图：0-1背包问题(动态规划)：#include<iomanip>#include<iostream>using namespace std;void knapsack(int v[], int *w, int c, int n, int**m) {int jmax = min(w[n] - 1, c); //1) 仅可选物品n时，容量为j的子问题的最优值for (int j = 0; j <= jmax; j++) m[n][j] = 0; //注意j为整数for (int j = w[n]; j <= c; j++) m[n][j] = v[n];for (int i = n - 1; i>0; i--) { //2) 逐步增加物品数至n及容量至cjmax = min(w[i] - 1, c); //仅可选物品i时，容量为j的子问题的最优值for (int j = 0; j <= jmax; j++) m[i][j] = m[i + 1][j];for (int j = w[i]; j <= c; j++) m[i][j] = max(m[i + 1][j], m[i + 1][j - w[i]] + v[i]);}m[1][c] = m[2][c]; //处理物品1，最后一件的边界情况if (c >= w[1]) m[1][c] = max(m[1][c], m[2][c - w[1]] + v[1]);}void traceback(int **m, int *w, int c, int n, int *x){for (int i = 1; i<n; i++) {if (m[i][c] == m[i + 1][c])x[i] = 0; //二者相等说明物品i不装入else {x[i] = 1;c = c - w[i];}x[n] = (m[n][c]) ? 1 : 0;}}int max(int a, int b){return a > b ? a : b;}int min(int a, int b){return a > b ? b : a;}int main(){int n, c;cout << "请输入物品数：" << endl;cin >> n;cout << "请输入背包容量：" << endl;cin >> c;int *v = new int[n + 1];int *w = new int[n + 1];cout << "请输入物品重量数组：" << endl;for (int i = 1; i < n + 1; i++)cin >> w[i];cout << "请输入物品价值数组：" << endl;for (int i = 1; i < n + 1; i++)cin >> v[i];int **p = new int*[n + 1];//子问题最优解for (int i = 1; i < n + 1; i++)p[i] = new int[c+1];int *x = new int[n + 1];knapsack(v, w, c, n, p);traceback(p, w, c, n, x);cout << "m(i,j):" << endl;for (int i = 5; i > 0; i--){for (int j = 0; j < 11; j++)cout <<setw(2)<< p[i][j] << ' ';cout << endl;}cout << "xi = ";for (int i = 1; i < 6; i++)cout << x[i] << ' ';cout << endl;cout << "V=" << p[1][c] << endl;for (int i = 1; i < n + 1; i++)//delete delete p[i];delete p;delete v, w;return 0;}运行截图：0-1背包问题（回溯法）#include<iostream>using namespace std;int n, c, bestp; //物品的个数，背包的容量，最大价值int p[10000], w[10000], x[10000], bestx[10000]; //物品的价值，物品的重量，x[i]暂存物品的选中情况,物品的选中情况void Backtrack(int i, int cp, int cw){ //cw当前包内物品重量，cp当前包内物品价值int j;if (i>n) //回溯结束{if (cp>bestp){bestp = cp;for (i = 0; i <= n; i++) bestx[i] = x[i];}}elsefor (j = 0; j <= 1; j++){x[i] = j;if (cw + x[i] * w[i] <= c){cw += w[i] * x[i];cp += p[i] * x[i];Backtrack(i + 1, cp, cw);cw -= w[i] * x[i];cp -= p[i] * x[i];}}}int main(){int i;bestp = 0;cout << "请输入物品数:" << endl;;cin >> n;cout << "请输入背包容量:" << endl;cin >> c;cout << "请输入物品重量数组:" << endl;;for (i = 1; i <= n; i++)cin >> w[i];cout << "请输入物品价值数组:" << endl;for (i = 1; i <= n; i++)cin >> p[i];Backtrack(1, 0, 0);cout << "V = "<< bestp << endl;cout << "xi = ";for (i = 1; i <= n; i++)cout << bestx[i] << ' ';cout << endl;system("pause");return 0;}运行截图：0-1背包问题（分支限界法）：#include <iostream>using namespace std;class Object {friend int Knapsack(int *, int *, int, int, int *); public:int operator <= (Object a) const {return (d >= a.d);}private:int ID; //物品编号float d; //单位重量价值};class bbnode {friend class Knap;friend int Knapsack(int *, int *, int, int, int *);private:bbnode * parent; //指向父节点的指针int LChild; //如果是左儿子结点取1，也即说明该物品已装进背包};class HeapNode {friend class Knap;friend class MaxHeap;public:operator int()const { return uprofit; };private:int uprofit, //结点的价值上界profit; //结点所相应的价值int weight; //结点所相应的重量int level; //活结点在子集树中所处的层序号bbnode *ptr; //指向该活结点在子集树中相应结点的指针};class MaxHeap {public:MaxHeap(int maxElem){HeapElem = new HeapNode*[maxElem + 1]; //下标为0的保留capacity = maxElem;size = 0;}void InsertMax(HeapNode *newNode);HeapNode DeleteMax(HeapNode* &N);private:int capacity;int size;HeapNode **HeapElem;};//0-1背包问题的主类class Knap {//Knapsack主函数功能：解决初始化、求解最优值和最优解、回收内存friend int Knapsack(int *, int *, int, int, int *);public:int MaxKnapsack();private:MaxHeap * H;//Bound辅助Maxknapsack函数：计算结点价值上界int Bound(int i);//AddLiveNode辅助Maxknapsack函数：将活结点插入子集树和优先队列中void AddLiveNode(int up, int cp, int cw, int ch, int level);bbnode *E; //指向扩展结点的指针int c; //背包容量int n; //物品总数int *w; //物品重量数组（以单位重量价值降序）int *p; //物品价值数组（以单位重量价值降序）int cw; //当前装包重量int cp; //当前装包价值int *bestx; //最优解};void MaxHeap::InsertMax(HeapNode *newNode){//极端情况下暂未考虑,比如堆容量已满等等int i = 1;for (i = ++size; i / 2 > 0 && HeapElem[i / 2]->uprofit < newNode->uprofit; i /= 2){HeapElem[i] = HeapElem[i / 2];}HeapElem[i] = newNode;}HeapNode MaxHeap::DeleteMax(HeapNode *&N){//极端情况下暂未考虑if (size >0){N = HeapElem[1];//从堆顶开始调整int i = 1;while (i < size){if (((i * 2 + 1) <= size) && HeapElem[i * 2]->uprofit > HeapElem[i * 2 + 1]->uprofit){HeapElem[i] = HeapElem[i * 2];i = i * 2;}else{if (i * 2 <= size){HeapElem[i] = HeapElem[i * 2];i = i * 2;}elsebreak;}}if (i < size)HeapElem[i] = HeapElem[size];}size--;return *N;}int Knap::MaxKnapsack(){H = new MaxHeap(1000);bestx = new int[n + 1];//初始化,为处理子集树中的第一层做准备,物品i处于子集树中的第i层int i = 1; //生成子集树中的第一层的结点E = 0; //将首个扩展点设置为null，也就是物品1的父节点cw = 0;cp = 0;int bestp = 0; //当前最优值int up = Bound(1); // 选取物品1之后的价值上界//当选择左儿子结点时，上界约束up不用关心，重量约束wt 需要考虑。

实验四回溯算法和分支限界法(精)

实验四回溯算法和分支限界法0-1背包问题一、实验目的:1、掌握0-1背包问题的回溯算法；2、进一步掌握回溯算法。

二、实验内容给定n和物品和一人背包，物品i的重量是wi，其价值为vi，问如何选择装入背包的物品，使得装入背包的物品的总价值最大？三、实验步骤1、代码// HS_ALG.cpp : Defines the entry point for the console application.//#include#includeusing namespace std;// 物体结构体typedef struct{float w; //物品重量float p; //物品价值float v; //背包体积int id; //物品个数}OBJECT;bool cmp(OBJECT a, OBJECT b{ //比较两物品体积return a.v>b.v;}float knapsack_back(OBJECT ob[], float M, int n, bool x[]{ //回溯法int i,k;float w_cur, p_total, p_cur, w_est, p_est;bool *y = new bool[n+1];// 计算物体的价值重量比for(i=0; i<=n; i++{ob[i].v = ob[i].p/ob[i].w;y[i] = false;}// 按照物体的价值重量比降序排列sort(ob, ob+n, cmp;// 初始化当前背包中的价值、重量w_cur = p_cur = p_total = 0;// 已搜索的可能解的总价值初始化k = 0;while(k>=0{w_est = w_cur; p_est = p_cur;// 沿当前分支可能取得的最大价值for( i=k; iw_est += ob[i].w;if(w_estp_est += ob[i].p;}else{p_est += ((M-w_est+ob[i].w/ob[i].w*ob[i].p; break;}}// 估计值大于上界if(p_est>p_total{for(i=k; iif(w_cur+ob[i].w<=M{// 可装入第i个物体w_cur = w_cur + ob[i].w;p_cur = p_cur + ob[i].p;y[i] = true;}else{// 不能装入第i个物体y[i] = false;break;}}if(i>=n{// n个物体已经全部装入if(p_cur>p_total{// 更新当前上限p_total = p_cur;k = n;// 保存可能的解for(i=0; ix[i] = y[i];}}}else{// 继续装入物体k = i+1;}}else{// 估计值小于上界时while((i>=0&&(!y[i]i--; // 沿着右分支结点方向回溯直到左分支结点if(i<0break; // 到达根结点算法结束else{ // 修改当前值w_cur -= ob[i].w;p_cur -= ob[i].p;y[i] = false;k = i+1; // 搜索右分支子树}}}//delete y;return p_total;}int main({int n;float m;cout<<"请输入背包载重：";cin>>m;cout<<"请输入物品个数：";cin>>n;OBJECT* ob = new OBJECT[n];{cout<<"请输入物品的重量、价格："< for(int i=0; icin>>ob[i].w>>ob[i].p;ob[i].id = i+1;}}bool* x = new bool[n];float v = knapsack_back(ob, m, n, x; {cout<<"最优方案："<for(int i=0; iif(x[i]cout<<"["<}cout<cout<<"物品总价值为："<}return 0;}2、结果执行成功.3、结果分析。

回溯算法应用实验报告

一、实验目的通过本次实验，旨在掌握回溯算法的基本原理和应用方法，加深对回溯算法的理解，并学会运用回溯算法解决实际问题。

实验内容包括：设计回溯算法解决八皇后问题、0-1背包问题以及TSP问题，并对算法进行时间复杂度和空间复杂度的分析。

二、实验内容1. 八皇后问题问题描述：在8x8的国际象棋棋盘上，放置8个皇后，使得它们互不攻击。

即任意两个皇后不能在同一行、同一列或同一斜线上。

算法设计：使用回溯算法，通过递归尝试在棋盘上放置皇后，当出现冲突时回溯到上一步，重新尝试。

代码实现：```pythondef is_valid(board, row, col):for i in range(row):if board[i] == col or abs(board[i] - col) == abs(i - row):return Falsereturn Truedef solve_n_queens(n):def backtrack(row):if row == n:result.append(board[:])returnfor col in range(n):if is_valid(board, row, col):board[row] = colbacktrack(row + 1)board[row] = -1board = [-1] nresult = []backtrack(0)return result```2. 0-1背包问题问题描述：给定n个物品，每个物品有一个价值v[i]和重量w[i]，以及一个背包容量W，如何选择物品使得背包中的物品总价值最大且不超过背包容量。

算法设计：使用回溯算法，递归尝试选择每个物品，当背包容量不足或物品价值超过剩余容量时回溯到上一步。

代码实现：```pythondef knapsack(weights, values, capacity):def backtrack(i, cw, cv):if cw > capacity or i == len(weights):return cvif not backtrack(i + 1, cw, cv):return cvif cw + weights[i] <= capacity:return max(backtrack(i + 1, cw, cv), backtrack(i + 1, cw + weights[i], cv + values[i]))else:return cvreturn backtrack(0, 0, 0)```3. TSP问题问题描述：给定n个城市，以及每对城市之间的距离，求出一条最短路径，使得路径上的城市互不相同，并且最终回到起点。

实验四回溯法

宁德师范学院计算机系
实验报告
（—学年第学期）
课程名称算法设计与分析
实验名称实验四贪心算法
专业
年级
学号姓名
指导教师
实验日期
算法运行结果：
时间复杂性和空间复杂性:
在n皇后问题的可能解中，考虑到约束条件xi不等于xj，则可能解应该是（1,2,3...,n)的一个排列，对应的解空间树中有n!叶子节点，每个叶子节点代表一种可能解。

如果棋盘的长度n=8的话应该是O(n^16),但事实上应该比这快很多,因为O(n^16)会成一个很小的系数,比如第一个顶点要考虑8*8的情况,在确定第二个顶点的时候就是小于7*7的情况了。

空间复杂性为1。

s[St[top].i][St[top].j] = 0; //让该位置变成其它路径可走方块 top--;
}
}
outfile<< "没有可走路径！\n";
}
int main()
{
ifstream infile("input.txt");
if(!infile)
{cerr<<"open file input error!"<<endl;
return -1;
}
int n;
infile>>n; //输入二维数组的行、列数n； MgPath(1,1,n-2,n-2,n);
}
实验结果：
注：1、报告内的项目或设置，可根据实际情况加以补充和调整
2、教师批改学生实验报告应在学生提交实验报告10日内。

回溯法解背包问题实验报告

实验4回溯法解0-1背包问题一、实验要求1．要求用回溯法求解0-1背包问题；2．要求交互输入背包容量，物品重量数组，物品价值数组；3．要求显示结果。

二、实验仪器和软件平台仪器：带usb接口微机软件平台：WIN-XP + VC++6.0三、实验源码#include "stdafx.h"#include<iostream>#include<cstdio>#include<conio.h>#include<iomanip>using namespace std;template<class ty>class Knap{public:friend void Init();friend void Knapsack();friend void Backtrack(int i);friend float Bound(int i);bool operator<(Knap<ty> a)const{if(fl<a.fl) return true;else return false;}private:ty w; //重量ty v; //价值float fl; //单位重量的价值v/wint kk; //记录第几个物品int flag; //记录是否放入包中};template<class ty>void Sort(Knap<ty> *li,int n){int i,j,k; Knap<ty> minl;for(i=1;i<n;i++){minl=li[0]; k=0;for(j=1;j<=n-i;j++){if(minl<li[j]){minl=li[j]; swap(li[j],li[k]); k=j;}}}}namespace jie //命名空间{int c=0,n=0;int *x=NULL;Knap<int> *bag=NULL;int cp=0,cw=0;int bestp=0;}using namespace jie;void Init(){int i=0;cout<<endl;cout<<"请输入物品数量n = ";cin>>n; cout<<endl;cout<<"请输入背包容量C = ";cin>>c; cout<<endl;bag=new Knap<int> [n];x=new int[n];cout<<"请依次输入"<<n<<"个物品的重量W:"<<endl;for(i=0;i<n;i++)cin>>bag[i].w;cout<<endl;cout<<"请依次输入"<<n<<"个物品的价值P:"<<endl;for(i=0;i<n;i++)cin>>bag[i].v;for(i=0;i<n;i++){bag[i].flag=0; bag[i].kk=i;bag[i].fl=1.0*bag[i].v/bag[i].w;}}void Backtrack(int i){if(i>=n) //到达叶节点{bestp=cp; //更新最优价值return;}if(cw+bag[i].w<=c) //进入左子树{bag[i].flag=1; cw+=bag[i].w;cp+=bag[i].v; Backtrack(i+1);cw-=bag[i].w; cp-=bag[i].v;}if(Bound(i+1)>bestp)//进入右子树{bag[i].flag=0; Backtrack(i+1);}}//计算当前节点处的上界float Bound(int i){int cleft = c-cw; //剩余容量float b = cp;while (i<n&&bag[i].w<=cleft){//以物品单位重量价值递减序装入cleft-=bag[i].w ;b+=bag[i].v;i++;}//装满背包if (i<n) b+=1.0*bag[i].v/bag[i].w * cleft;return b;}void Knapsack() //计算最优解和变量值{int L(0); //用L累计价值，初始价值设置为0for(int k=0;k<n;k++){x[bag[k].kk]=bag[k].flag; //x=0表示未放入背包，x=1表示放入背包L+=bag[k].flag*bag[k].v; //价值累加}cout<<endl;cout<<"当前最优价值为:"<<L<<endl;cout<<"变量值x = ";for(int i=1;i<=n;i++){cout<<x[i-1];}delete []bag; bag=NULL;delete []x; x=NULL;cout<<endl; getch();}int main(){cout<<endl;cout<<"|**********回溯法解0-1背包问题**********|"<<endl;Init();Backtrack(0);Knapsack();return 0;}四、运行结果五、实验小结通过该实验，我充分了解了回溯法与分支界限法的区别。

实验4回溯法

淮海工学院计算机工程学院实验报告书课程名：《算法分析与设计》题目：实验4 回溯算法0/1背包问题班级：学号：姓名：实验4 回溯算法实验目的和要求（1）掌握回溯法的设计思想；（2）掌握解空间树的构造方法，以及在求解过程中如何存储求解路径；（3）考察回溯法求解问题的有效程度。

（4）设计可能解的表示方式，构成解空间树；（5）设计回溯算法完成问题求解；（6）设计测试数据，统计搜索空间的结点数；实验内容给定n 种物品和一个容量为C 的背包，物品i 的重量是wi ，其价值为vi ，0/1背包问题是如何选择装入背包的物品（物品不可分割），使得装入背包中物品的总价值最大? 实验环境Turbo C 或VC++ 实验学时2学时，必做实验数据结构与算法递归算法：void Backtracking(int i)非递归算法---迭代算法：void beibao(int i)核心源代码1. 递归：void Backtracking(int i) {if(i>n) {Print(); return; }if(currentWeight+weight[i]<=content) { //将物品i 放入背包，搜索左子树 nowAnswer[i] = 1;currentWeight += weight[i]; nPrice += price[i];Backtracking(i+1); //完成上面的递归，返回到上一结点，物品i 不放入背包，准备递归右子树t++;currentWeight -= weight[i]; nPrice -= price[i];∑=ji k k a}nowAnswer[i] = 0;Backtracking(i+1);t++;}void Print(){if(nPrice>=bestPrice){bestPrice=nPrice;for(int i=1;i<n;++i){bestAnswer[i]=nowAnswer[i];}}}2.迭代:void beibao(int n){int i,k;for (i=1; i<=n; i++) //初始化x[i]=0;k=1;while (k>=1){t++;x[k]=x[k]+1; //第k个物品放入背包if (x[k]<=2 && k==n){ //得到一个解，输出int currentweight=0,nowprice=0;for (i=1; i<=n; i++){if(x[i]==1){currentweight+=w[i];nowprice+=p[i];}}if((currentweight<=content)&&(nowprice>bestprice)) {for(int j=1;j<=n;j++){put[j]=x[j];if(put[j]==2)put[j]=0;}bestprice=nowprice;}}else if (x[k]<=2 && k<n)k=k+1; //放置下一个物品else{x[k]=0; //拿走第k个物品，重置x[k]，回溯 k=k-1;}}}实验结果递归法要比迭代法优化。

算法设计与分析实验指导4_回溯法：排兵布阵

《算法设计与分析》实验指导实验四回溯法一、实验目的：1. 理解回溯法的深度优先搜索策略。

2. 掌握用回溯法解题的算法框架。

3. 掌握回溯法的设计策略。

二、实验指导1. 回溯法的总体思想回溯法的基本做法是搜索，或是一种组织得井井有条的，能避免不必要搜索的穷举式搜索法。

这种方法适用于解一些组合数相当大的问题。

回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。

算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。

如果肯定不包含，则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索。

2. 贪心算法的基本步骤⑴针对所给问题，定义问题的解空间；⑵确定易于搜索的解空间结构；⑶以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。

3. 程序参考template<typename Type> //交换两个变量的值void Swap(Type &a,Type &b){Type t=b;b=a;a=t;}template<typename Type> //创建二维数组void TwoDimArray(Type** &p,int r,int c){p=new Type *[r];for(int i=0; i<r; i++)p[i]=new Type[c];for(int i=0;i<r;i++)for(int j=0;j<c;j++)p[i][j]=0;}template<typename Type> //输出一维数组的元素void Print1(Type a[],int n){for(int i=1; i<=n; i++)cout<<a[i]<<' ';cout<<endl;}三、实验内容及要求：1. 排兵布阵问题某游戏中，不同的兵种处在不同的地形上其攻击能力不一样，现有n个不同兵种的角色{1,2,...,n}，需安排在某战区n个点上，角色i在j点上的攻击力为A ij。