实验四 回溯法
4 回溯法 (2)
图的m-着色问题(a)地图(b)地图对应的平面图图4-17 一幅地图及其相应的平面图用5种颜色就足以对任何一幅地图着色在很早以前就已经被证明了，然而却一直找不到一幅需要4种以上颜色才能够着色的地图，因此才有了“4色猜想”。
直到1976年美国的爱普尔(Appel), 黑肯(Haken)和考西(Koch)等利用高速计算机, 花了1200小时证明了“4色猜想”是成立的。
从此，“4色猜想”就变成了4色定理。
本节所要考虑的是所有无向连通图。
同时要找出用m种颜色给此图着色的所有方法。
使用邻接矩阵G(i, j)来存储图。
其中(i, j)是图G中的一条边，i和j则是图G中的两个顶点，此时G(i, j)=1，否则G(i, j)=0。
对于m种不同的颜色可以用1到m的整数表示，那么问题的解可以表示成一个n元组(x1, x2, …, x n)，其中n是图G中顶点的个数，x i 就表示顶点i所着的颜色值。
假设图G有n个顶点，m种颜色，那么问题的状态空间树就可以表示为高是n+1，每个结点的度都是m。
即第i(i∈[1,n])层上的结点都有m个儿子结点，这正好与x i 有m种可能的取值相对应。
为了方便描述，这里给出一棵m=3,n=3的状态空间树。
图4-18 当m=3且n=3时的状态空间树当顶点1到顶点k-1都被着色之后，要从m种颜色种选出一种可行的颜色给顶点k着色，如果所有颜色都不可行，那么解向量中x k =0。
给第k个顶点挑选可行的颜色的函数我们可以实现如下。
用数组x[n]存储解向量，其中所有元素初始化为0，在进入此函数之前，前k-1个元素已经被赋予1 到m之中的某一个整数值，而且在图中相邻接的两个顶点的值不相等。
m是颜色的数目，n是顶点的数目。
G[n][n]是图G的邻接矩阵，mod是取模运算。
输入：顶点k，图的邻接矩阵，及其顶点数n，色数m输出：返回表示是否找到颜色的bool值NextColor()函数的代码描述：NextColor(int k , bool G[][] ,int m , int n , int x[])1 int j;2 while true3 do{4 x[k] ←(x[k] + 1) mod (m + 1); //检测是否还有可用的颜色值，若有将5 //其赋给x[k]，否则令x[k]=0；6 if x[k] = 07 then{ //如果找不到可用的颜色，函数返回值为0，表示着色失败；8 return 0;9 }10 for j ←1 to n11 do{//检测顶点k所着的颜色是否和与其相邻接的顶点的所着颜色不同；12 ifG[k][j]=1 and x[k]=x[j]//若顶点k所着的颜色与它的一个13then break; //邻接点所着的颜色相同，则要给它换下一种颜色；14 }15 if j = n //找到一种可用的颜色，函数返回值1，表示对顶点k着色16 then return 1; //成功。
回朔法实验报告
一、实验目的1. 理解回溯法的基本原理和适用场景。
2. 掌握回溯法在解决实际问题中的应用。
3. 通过实验，提高编程能力和算法设计能力。
二、实验背景回溯法是一种在计算机科学中广泛应用的算法设计方法。
它通过尝试所有可能的解，在满足约束条件的前提下，逐步排除不满足条件的解，从而找到问题的最优解。
回溯法适用于解决组合优化问题，如0-1背包问题、迷宫问题、图的着色问题等。
三、实验内容本次实验以0-1背包问题为例，采用回溯法进行求解。
1. 实验环境：Windows操作系统，Python 3.7以上版本。
2. 实验工具：Python编程语言。
3. 实验步骤：（1）定义背包容量和物品重量、价值列表。
（2）定义回溯法函数，用于遍历所有可能的解。
（3）在回溯法函数中，判断当前解是否满足背包容量约束。
（4）若满足约束，则计算当前解的价值，并更新最大价值。
（5）若不满足约束，则回溯至前一步，尝试下一个解。
（6）输出最优解及其价值。
四、实验结果与分析1. 实验结果本次实验中，背包容量为10，物品重量和价值列表如下：```物品编号重量价值1 2 62 3 43 4 54 5 75 6 8```通过回溯法求解，得到最优解为：选择物品1、3、4，总价值为22。
2. 实验分析（1）回溯法能够有效地解决0-1背包问题，通过遍历所有可能的解，找到最优解。
（2）实验结果表明，回溯法在解决组合优化问题时具有较高的效率。
（3）在实验过程中，需要合理设计回溯法函数，以提高算法的效率。
五、实验总结通过本次实验，我们了解了回溯法的基本原理和适用场景，掌握了回溯法在解决实际问题中的应用。
在实验过程中，我们提高了编程能力和算法设计能力，为今后解决类似问题奠定了基础。
在今后的学习和工作中，我们将继续深入研究回溯法及其应用，以期为解决实际问题提供更多思路和方法。
实验报告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;}。
实验四N皇后问题求解
实验四N 皇后问题求解、题目1) 以Q-皇后问题为例，掌握回溯法的基本设计策略。
2) 掌握回溯法解决Q-皇后问题的算法并实现；二、算法设计思想回溯法是在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。
当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。
(其实回溯法就是对隐式图的深度优先搜索算法)。
若用回溯法求问题的所有解时，要回溯到根，且根结点的所有可行的子树都要已被搜索遍才结束。
而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。
判断解是否可行的条件：1. 不在同一行或者同一列，x[i]!=x[j],i!=j2•不在一条斜线上，设两个皇后在(i,j)和(k,l)位置，卜k|!=|j-l|三、程序#include<stdio.h>#include<stdlib.h>int n,stack[100]; // 存当前路径int total; // 路径数int att(int,int);void make(int l) //递归搜索以stack[l]为初结点的所有路径｛int i,j; //子结点个数if (l==n+1){total=total+1; // 路径数+1 for(i=1;i<=n;i++)printf(" 输出皇后的列位置%-3d",stack[i]);// 输出第i 行皇后的列位置stack[i]}int att(int l,int i){}for (i=1;i<=n;i++){stack[l]=i; II算符i 作用于生成stack[l-1]产生子状态stack[l];if (!att(l,i))make(l+1);printf("\n");exit; II 回溯} II 再无算符可用，回溯int k;for (k=1;k<l;k++)if (abs(l-k)==abs(stack[k]-i)||i==stack[k])return 1;return 0;}int main(){}四、运行结果printf("N=");scanf("%d",&n);total=0; II 路径数初始化为0make(1); II从结点1出发，递归搜索所有的路径printf("%d\n",total);system("pause");return 0;六、心得体会在解决N皇后的时候一开始有点不止如何着手，因为这里有个N的不确定性，所以选择简单少量的情况进行具体考虑显得相对容易了许多，还有一个值得注意的问题就是如何判断要不要重新开始搜索，并且在已经形成的简单模型基础上进行改进，使之也能满足后面较复杂情况。
实验四 回溯法
实验四回溯法（4学时）上机实验一般应包括以下几个步骤：（1）、准备好上机所需的程序。
手编程序应书写整齐，并经人工检查无误后才能上机。
（2）、上机输入和调试自己所编的程序。
一人一组，独立上机调试，上机时出现的问题，最好独立解决。
（3）、上机结束后，整理出实验报告。
实验报告应包括：题目、程序清单、运行结果、对运行情况所作的分析。
一、实验目的与要求1.掌握回溯法的基本思想方法；理解回溯法的基本思想，理解回溯法算法的两个基本要素最优子结构性质和子问题的重叠性质。
熟练掌握典型的回溯法问题。
2.了解适用于用回溯法求解的问题类型，并能设计相应回溯法算法；3.掌握回溯法算法复杂性分析方法分析问题复杂性。
二、实验内容（以下题目要求采用回溯法算法完成）：1、N皇后问题八皇后问题是十九世纪著名的数学家高斯于1850年提出的。
问题是：在8×8的棋盘上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上。
可以把八皇后问题扩展到n皇后问题，即在n×n的棋盘上摆放n个皇后，使任意两个皇后都不能处于同一行、同一列或同一斜线上。
如下图所示：其中图中的一个解为：4 6 8 2 7 1 3 5N皇后问题(含八皇后问题的扩展，规则同八皇后)：在N*N的棋盘上，放置N个皇后，要求每一横行每一列，每一对角线上均只能放置一个皇后，求解可能的方案及方案数。
1.运用回溯法，设计解决上述问题的算法，设计出用回溯法计算出在N*N的棋盘上，放置N个皇后，要求每一横行每一列，每一对角线上均只能放置一个皇后，并返回每个皇后的位置。
2.掌握回溯算法的应用。
2、0-1背包问题给定n种物品和一背包。
物品i的重量是wi>0，其价值为vi>0，背包的容量为c。
问应如何选择装入背包中的物品，使得装入背包中物品的总价值最大？利用回溯法试设计一个算法求出0-1背包问题的解，也就是求出一个解向量ｘi(ｘi = 0 或１，ｘi = 0表示物体ｉ不放入背包，ｘi ＝1表示把物体ｉ放入背包），3、装载问题有两艘船，它们的可装载的货物重量分别为才c1，c2，给定一批货物，其重量保存在数组w 【i】中了，问这批货物能否用此两艘船送出。
用回溯算法解n皇后问题实验步骤
湖州师范学院实验报告课程名称：算法实验四：回溯算法一、实验目的1、理解回溯算法的概念，掌握回溯算法的基本要素。
2、掌握设计回溯算法的一般步骤，针对具体问题，能应用回溯算法求解。
二、实验内容1、问题描述1 ）n后问题在n×n格的棋盘上放置彼此不受攻击的n个皇后。
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n后问题等价于在n×n格的棋盘上放置n个皇后，任何2个皇后不放在同一行或同一列或同一斜线上。
2）0-1 背包问题需对容量为 c 的背包进行装载。
从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。
对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高。
每种物品要么放进背包，要么丢弃。
2、数据输入：文件输入或键盘输入。
3、要求：1）完成上述两个问题，时间为2 次课。
2）独立完成实验及实验报告。
三、实验步骤1、理解方法思想和问题要求。
2、采用编程语言实现题目要求。
3、上机输入和调试自己所写的程序。
4、附程序主要代码：1.n后问题：#include<iostream>using namespace std;class Queen {friend int nQueen(int);private:bool Place(int k);void Backtrack(int t);int n,*x;long sum;};bool Queen::Place(int k) {for (int j = 1; j < k; j++)if ((abs(k - j) == abs(x[j] - x[k])) || (x[j] == x[k]))return false;return true;}void Queen::Backtrack(int t) {if (t > n) {for (int i = 1; i <= n; i++)cout << x[i] << " ";cout << endl;sum++;}else {for (int i = 1; i <= n; i++) {x[t] = i;if (Place(t)) Backtrack(t + 1);}}}int nQueen(int n) {Queen X;//初始化XX.n = n;X.sum = 0;int* p = new int[n + 1];for (int i = 0; i <= n; i++)p[i] = 0;X.x = p;X.Backtrack(1);delete [] p;return X.sum;}void main() {int n, set;cout << "请输入皇后个数："; cin >> n;cout << "可行方案所有解：" << endl;set = nQueen(n);cout << "可行方案数：" << set << endl;}2.0-1背包：#include <stdio.h>#include <conio.h>int n;//物品数量double c;//背包容量double v[100];//各个物品的价值double w[100];//各个物品的重量double cw = 0.0;//当前背包重量double cp = 0.0;//当前背包中物品价值double bestp = 0.0;//当前最优价值double perp[100];//单位物品价值排序后int order[100];//物品编号int put[100];//设置是否装入//按单位价值排序void knapsack(){int i,j;int temporder = 0;double temp = 0.0;for(i=1;i<=n;i++)perp[i]=v[i]/w[i];for(i=1;i<=n-1;i++){for(j=i+1;j<=n;j++)if(perp[i]<perp[j]) perp[],order[],sortv[],sortw[] {temp = perp[i];perp[i]=perp[i];perp[j]=temp;temporder=order[i]; order[i]=order[j]; order[j]=temporder; temp = v[i];v[i]=v[j];v[j]=temp;temp=w[i];w[i]=w[j];w[j]=temp;}}}//回溯函数void backtrack(int i){double bound(int i);if(i>n){bestp = cp;return;}if(cw+w[i]<=c){cw+=w[i];cp+=v[i];put[i]=1;backtrack(i+1);cw-=w[i];cp-=v[i];}if(bound(i+1)>bestp)//符合条件搜索右子数 backtrack(i+1);}//计算上界函数double bound(int i){double leftw= c-cw;double b = cp;while(i<=n&&w[i]<=leftw){leftw-=w[i];b+=v[i];i++;}if(i<=n)b+=v[i]/w[i]*leftw;return b;}int main(){int i;printf("请输入物品的数量和容量：");scanf("%d %lf",&n,&c);printf("请输入物品的重量和价值：");for(i=1;i<=n;i++){printf("第%d个物品的重量：",i);scanf("%lf",&w[i]);printf("价值是：");scanf("%lf",&v[i]);order[i]=i;}knapsack();backtrack(1);printf("最有价值为：%lf\n",bestp);printf("需要装入的物品编号是：");for(i=1;i<=n;i++){if(put[i]==1)printf("%d ",order[i]);}return 0;}5、实验结果：四、实验分析1、：n后问题分析只要不要在同一直线和斜线上就行。
实验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;}四、心得体会这程序和以前做的迷宫问题很相象，写起来不是很困难. 确定限界函数，在只有满足限界函数的前提下得到解，不满足限界条件时就要回溯，回到上一个节点，再从另外的方向出发。
算法实验四 回溯法
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背包问题。因此是一棵子集树。
回溯法
算法实验报告四回溯法实验一、实验目的及要求利用回溯方法设计指派问题的算法，掌握回溯法的基本思想和算法设计的基本步骤。
要求：设计指派问题的回溯算法，注意回溯算法解决此问题要找出问题所有的可行解，然后一次比较保留问题的最优解(即最少耗费的解)，并输出结果。
利用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输出;结束三、调试过程及运行结果调试过程中出现的问题：虽然按照回溯算法所给的模式写完了程序，却不对，经单步调试发现是我的程序结构混乱，部分解和合法解还有非法解之间的条件处理那有问题，因为通过一个循环要保证一个人只能做一项工作，而且要做别人没做过的工作，此条件对于部分解、合法解都要求，而当它不满足时应跳出作另外处理。
实验四 回溯法
宁德师范学院计算机系
实验报告
（—学年第学期）
课程名称算法设计与分析
实验名称实验四贪心算法
专业
年级
学号姓名
指导教师
实验日期
算法运行结果：
时间复杂性和空间复杂性:
在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日内。
回溯法实验报告
回溯法实验报告回溯法实验报告一、引言回溯法是一种经典的算法解决方法，广泛应用于组合优化、图论、人工智能等领域。
本实验旨在通过实际案例，深入探讨回溯法的原理、应用和优化方法。
二、实验背景回溯法是一种通过不断尝试和回退的方式，寻找问题的解的方法。
它适用于那些问题空间巨大且难以直接求解的情况。
回溯法通过逐步构建解空间树，深度优先地搜索可能的解，并在搜索过程中剪枝，以提高搜索效率。
三、实验过程我们选择了一个经典的回溯法问题——八皇后问题作为实验案例。
该问题要求在一个8x8的棋盘上放置8个皇后，使得它们两两之间无法互相攻击。
我们采用了递归的方式实现回溯法，并通过剪枝操作来减少搜索空间。
具体实验步骤如下：1. 定义一个8x8的棋盘，并初始化为空。
2. 从第一行开始，逐行放置皇后。
在每一行中，尝试将皇后放置在每一个位置上。
3. 检查当前位置是否与已放置的皇后冲突。
如果冲突，则回溯到上一行，并尝试下一个位置。
4. 如果成功放置了8个皇后，则找到了一个解，将其保存。
5. 继续尝试下一个位置，直到所有可能的解都被找到。
四、实验结果通过实验，我们找到了92个不同的解，符合八皇后问题的要求。
这些解展示了八皇后问题的多样性，每个解都有其独特的棋盘布局。
五、实验分析回溯法的优点在于可以找到所有解，而不仅仅是一个解。
然而，在问题空间较大时，回溯法的搜索时间会变得非常长。
因此，为了提高搜索效率，我们可以采用一些优化方法。
1. 剪枝操作：在搜索过程中，当发现当前位置与已放置的皇后冲突时，可以立即回溯到上一行，而不是继续尝试下一个位置。
这样可以减少不必要的搜索。
2. 启发式搜索：通过引入启发函数，可以在搜索过程中优先考虑最有希望的分支，从而更快地找到解。
例如，在八皇后问题中，可以优先考虑放置在当前行与已放置皇后冲突最少的位置。
3. 并行计算：对于一些复杂的问题，可以利用并行计算的优势，同时搜索多个分支，从而加快搜索速度。
六、实验总结通过本次实验，我们深入了解了回溯法的原理和应用。
回溯法实验报告
一、实验目的1. 理解回溯法的概念和基本原理。
2. 掌握回溯法的应用场景和实现方法。
3. 通过具体实例，验证回溯法在解决实际问题中的有效性。
二、实验内容本次实验主要围绕回溯法进行，通过以下实例来验证回溯法在解决实际问题中的有效性：1. 八皇后问题2. 0/1背包问题3. 数独游戏三、实验步骤1. 八皇后问题（1）定义问题：在8×8的国际象棋棋盘上，放置8个皇后，使得它们不能相互攻击。
（2）设计回溯算法：① 初始化棋盘为全空状态。
② 从第一行开始，尝试将皇后放置在每一列。
③ 如果某一列放置皇后后，不会与已放置的皇后发生冲突，则继续在下一行尝试放置。
④ 如果某一列放置皇后后，与已放置的皇后发生冲突，则回溯至上一个放置皇后的行，尝试在下一列放置。
⑤ 当所有行都放置了皇后，则找到一个解。
（3）实现代码：```pythondef is_valid(board, row, col):for i in range(row):if board[i] == col or \board[i] - i == col - row or \board[i] + i == col + row:return Falsereturn Truedef solve_n_queens(board, row):if row == len(board):return Truefor col in range(len(board)):if is_valid(board, row, col):board[row] = colif solve_n_queens(board, row + 1):return Trueboard[row] = -1return Falsedef print_board(board):for row in board:print(' '.join(['Q' if x == row else '.' for x in range(len(board))]))def n_queens():board = [-1] 8if solve_n_queens(board, 0):print_board(board)else:print("No solution exists")n_queens()```2. 0/1背包问题（1）定义问题：给定n个物品，每个物品有重量和价值，背包容量为W，求出能够装入背包的物品组合，使得背包内物品的总价值最大。
实验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;}}}实验结果递归法要比迭代法优化。
实验四 回溯法(图的着色问题)
图的着色问题是由地图的着色问题引申而来的： 用m种颜色为地图着色，使得地图上的每一个 区域着一种颜色，且相邻区域颜色不同。 问题处理：如果连接，就可以把一 个区域图抽象为一个平面图。 地图（map）中地区的相邻关系，在图（graph） 中用边表示。
对应的邻接矩阵
0 0 1 2 3 4 0 1 1 0 1 1 1 0 1 0 1 2 1 1 0 1 0 3 0 0 1 0 1 4 1 1 0 1 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表示边数 };
}
void MGraph::NextValue(int k,int m,int *x) { //本函数在[1,m]中为x[k]确定一个值最小的，且不与其邻接点冲突的颜色
//x[k]=0 表示没有可用颜色，颜色从1开始编号
do {
x[k]=(x[k]+1) % (m+1); //尝试下一种颜色 if (x[k]==0) return; //已经试完所有颜色，没有可用颜色 for (int j=0; j<k; j++) if (a[k][j] && x[k] == x[j]) break;
无向图G
【实验内容与要求】
算法设计与分析实验指导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。
《回溯法实验》实验报告
实验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上的单独用时。
回溯法解背包问题实验报告
实验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;}四、运行结果五、实验小结通过该实验，我充分了解了回溯法与分支界限法的区别。
回溯与分支限界算法设计
row[j]=o;
}
void Swapcol(int i, int j){//将二进数进行列互换
int o;
o=col[i];
col[i]=col[j];
col[j]=o;
}
void reveR(int k){//将二进数进行行颠倒
int y=0, z=1<<(4-1);
程序及运行结果
1.骑士游历问题的程序：
package com.t5;
import java.util.Scanner;
public class Qishi{
private boolean Travel(int firstX, int firstY, int[][]board) {
//对应骑士可走的8个方向
for (int j = 0; j < board[0].length; j++) {
if (board[i][j] < 10) {
System.out.print(" " + board[i][j]);
} else {
System.out.print(board[i][j]);
}
System.out.print(" ");
c=chArrs[i];
graph.sour|=(int)(c-'0')<<i;
}
String sd=scanner.nextLine();
char[]chArrd=sd.toCharArray();
for(graph.dest=i=0;i<16;i++){
回溯法实验报告总结
回溯法实验报告总结
回溯法实验报告总结
引言
回溯法是一种常见的求解问题的算法，它通过不断尝试并回溯来寻找问题的最优解。
本次实验旨在探究回溯法在解决不同类型问题中的应用和效果。
实验一：八皇后问题
八皇后问题是一个经典的回溯法问题，其目标是在一个 8*8 的棋盘上放置 8 个皇后，使得每个皇后都不会互相攻击。
通过实现该问题，我们可以更好地理解回溯法的思想和过程。
实验二：0/1 背包问题
0/1 背包问题是另一个经典的回溯法问题，其目标是在给定一组物品和一个背包容量时，选择哪些物品放入背包中，使得背包中物品价值之和最大。
该问题可以用于优化算法设计和资源分配等领域。
实验三：数独游戏
数独游戏是一种基于逻辑推理和填空的益智游戏，也可以用回溯法来求解。
该游戏需要填写一个 9*9 的数独表格，使得每行、每列和每个
3*3 的小方格内都恰好包含数字 1~9，且不重复。
实验结果
通过对以上三个问题的实验，我们可以得出以下结论：
1. 回溯法在解决八皇后问题、0/1 背包问题和数独游戏等经典问题中具有较好的应用效果。
2. 在实现回溯法时，需要注意剪枝和优化等技巧，以提高算法效率和减少时间复杂度。
3. 回溯法虽然能够求解一些 NP 难问题，但在面对大规模数据和高维空间时往往会遇到困难。
结论
回溯法是一种常见的求解问题的算法，在许多领域中都有着广泛的应用。
通过本次实验，我们更加深入地了解了回溯法的思想和过程，并探究了其在不同类型问题中的应用和效果。
在今后的学习和研究中，我们将继续深入探究回溯法及其相关算法，并在实践中不断提高自己的编程能力。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
宁德师范学院计算机系
实验报告
（—学年第学期）
课程名称算法设计与分析
实验名称实验四贪心算法
专业
年级
学号姓名
指导教师
实验日期
算法运行结果：
时间复杂性和空间复杂性:
在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日内。