实验四 回溯法的应用------跳马算法
应用举例跳马问题动画演示
向），那么我们很容易得到每一个方向上两 个坐标和原位置的关系。
同时，四个方向都有了编号，那么在选择路
径的时候也就可以不采用任选的方式了，只 需按照编号依次尝试就可以了。
跳马问题
4 3 2 1
若马所处的位置为 (x,y) ， 则其下一步可以到达的四 个位置分别是(x+1, y-2)， (x+2, y-1)，(x+2, y+1)， (x+1, y+2)。
跳马问题
骑士遍历问题的解空间是从左下角到右上角
的所有路径。
解空间的长度是所有路径中最长的路径的长
度。
解空间的组织形式是一棵四叉树，一个可行
的解就是从根节点到叶子节点的一条路径。 控制策略则是马必须在棋盘内。
跳马问题（递归）
procedure search(k: integer); // 递归查找 begin for i := 1 to 4 do // 依次尝试四个方向 if (x + dx[i] <= n) and (y + dy[i] > 0) and (y + dy[i] <= n) then // 在棋盘上 begin route[k] := i; // 记录下当前方向 x := x + dx[i]; y := y + dy[i]; // 修改扩展节点坐标 if (x = n) and (y = m) then // 是否是目标点 begin output(k); halt; // 是目标点，输出结果并终止程序 end else search(k+1); // 不是目标点，继续尝试下一步 // 扩展出的点是死点，回溯 x := x - dx[i]; y := y - dy[i]; // 恢复扩展节点坐标 end; end;
《数据结构与算法分析》第4次实验
姓名
学号
班级
实验内容
跳马问题求解。
实验题目
跳马问题递归求解
跳马问题非递归求解（不做硬性要求，做出来有加分）
实验重点
在8*8的棋盘上，从任意指定方格出发，为象棋中的马找到一条经过每个格子一次且仅一次的一条路径。
对棋盘和跳马路径的程序建模。
实验说明
马走“日”字，如下图：
图中红“杨鹏宇\上传\12网络数据结构\第六次作业\”目录下。
使用递归的线性试探、回溯的方法，每当马到达一个位置时就选择一个前进方向试探是否能将马放到下一个位置，如果不能（越界和这一位置已被马走过），则回退到当前位置（回溯），在试探下一个位置，如果所有位置都试探完还是无法放置，则进一步回溯。
实验参考资料
C++程序设计(谭浩强完整版)及课程PPT
实验报告
提交内容包括程序.cpp源文件和你的ADT说明文件（word文件即可），打包后以“姓名+学号”的方式命名。
回溯算法及其案例用途
回溯算法及其案例⽤途回溯算法是⼀种递归模式，它是⼀种暴⼒求解⽅法(brute force method)，⽤于求出所有可能的解，回溯算法通常会构建⼀个状态空间树(state space tree),将可能的组和从根到叶节点进⾏展开，然后以深度优先的⽅式搜索遍历状态树，遍历过程中遇到不符合解的节点⽴马返回进⾏新的遍历，⽽不是继续遍历，状态空间树的结构可⽤下图进⾏描述：回溯算法不是⽤来求解最优解，⽽是⽤来求解可⾏解的⽅法，回溯算法的代码结构：Backtrack(x)if x is not a solutionreturn false // return directlyif x is a new solutionadd to list of solutionsbacktrack(expand x)根据以上结构，⽤具体的⽰例进⾏分析，例如：1、排队问题，假设有2个男孩和1个⼥孩，⼥孩不能站在男孩的中间，则可以⽤⼀个树的结构进⾏描述：树是构建好了，根据构建树构建代码：arrange-boy-girl(p,index,result,mem)://index ⽤于记录孩⼦的位置，result是最终的排列结果，mem⽤于记录孩⼦是否已经排在队中了 if index == p.length: print(result);//输出结果 // expand p for i =0 to p.length: if(index == 2 && p[i]=='girl' || mem[i] ==1)://位置2不能是⼥孩,且该⼩孩没有在队列中，继续进⾏循环 continue; result[index]=p[i];//将⼩孩排到队中 mem[i]=1;//记录⼀下，下次这个⼩孩不能再排了，因为已经在队伍中了 index++;//排下⼀个位置 arrange-boy-girl(p,index,result,mem);//递归调⽤，排下⼀个位置 index--;//注意这⾥，index恢复原值，表⽰原来的index位置还可以安排下⼀个⼩孩，⽐如，位置0可以是boy1,也可以是boy2 mem[i]=0;//这⾥也是，index恢复原值后，mem也要恢复原值以上是⼀个全排列问题，但是它有⼀些限制，就是⼥孩不能排到男孩⼉中间。
回溯算法
1.跳马问题：在n*m,棋盘上有一中国象棋中的马：1.马走日字；
2.马只能往右走。
请你找出一条可行路径，使得马可以从期盼的左下角(1,1)走到右上角(n,m)。
2.任何一个自然数x都可以被写成若干自然数之和的形式，如5=1+4;5=2+3;5=1+1+1+1+1;……现请你编写一个程序，给出自然数X的所有拆分等式(2+3和3+2视为相同形式)。
3.有形如下图形的地图，图中每一块区域
代表一个省份，现请你用红(1)、蓝(2)、黄(3)、
绿(4)四种颜色给这些省份填上颜色，要求每
一省份用一种颜色，且任意两个相邻省份的
颜色不能相同，请给出一种符合条件的填色
方案。
地图用无向图的形式给出，每个省份
代表图上的一个顶点，边代表两个省份是相
邻的。
回溯法(马周游问题)——实验报告
华南师范大学本科生实验报告姓名＿黎国庄＿学号20062101247院系＿计算机学院专业＿计算机科学与技术年级2006级班级＿2班＿小组实验任务分工＿独立完成实验时间2008 年＿6＿月 3 ＿日实验名称回溯法的应用指导老师及职称陈卫东老师华南师范大学教务处编印实验课程：算法分析与设计实验名称：回溯法的应用（综设型实验）第一部分实验内容1．实验目标（1）熟悉使用回溯法求解问题的基本思路。
（2）掌握回溯算法的程序实现方法。
（3）理解回溯算法的特点。
2. 实验任务（1）从所给定的题目中选择一题，使用回溯法求解之。
（2）用文字来描述你的算法思路，包括解空间、限界函数、算法主要步骤等。
（3）在Windows环境下使用C/C++语言编程实现算法。
（4）记录运行结果，包括输入数据，问题解答及运行时间。
（5）分析算法最坏情况下时间复杂度和空间复杂度。
（6）谈谈实验后的感想，包括关于该问题或类似问题的求解算法的建议。
3. 实验设备及环境PC；C/C++等编程语言。
4. 实验主要步骤(1)根据实验目标，明确实验的具体任务；(2)设计求解问题的回溯算法，并编写程序实现算法；(3)设计实验数据并运行程序、记录运行的结果；(4)分析算法时空性能；(5)实验后的心得体会。
第二部分问题及算法1.问题描述给出一个8×8的棋盘，一个放在棋盘某个位置上的马（规定马的走法为走“日”）是否可以恰好访问每个方格一次，并回到起始位置上？2. 回溯法的一般思路对于马所在其中一格时，它可以走的位置有以下8种情况：⑧①⑦②马⑥③⑤④所以对于每一个马所在的格子里，马可以走对应的8个方向。
用满8叉树，每一个子树对应马可跳的方向当要走下一子树（跳下一格）时，该子树可走（还没有走过并且在棋盘里边），即沿该方向走下去，当不可以走，即回溯到上一步，选择另一方向往下走；当该子树的8个子棋都遍历完了（即8个方向都走过了），则回溯到它父亲那里。
重复一直做下去，到棋盘每个格子都走过一遍，而且回到出发点或者找不到路径即结束。
lab6_回溯算法设计与应用
实验六回溯算法设计与应用一．基本原理的概括DFS+剪枝（在状态空间树上作带剪枝的DFS搜索）➢剪枝：若搜索到某结点，其对应的部分解不满足解的约束条件且可断定以其为根的子树上不包含答案结点，则不搜索该子树，直接回到其父结点，继续DFS。
利用回溯法可求问题的一个解，多个解，所有解，最优解，还可判断解的存在性。
二．该类算法设计与实现的要点回溯法通常包含以下3个步骤：1)定义给定问题的解空间；2)确定并表示解的约束条件和其它的剪枝条件；3)结合剪枝深度优先搜索相应的状态空间树。
注意：回溯法的一个特征是在搜索过程中动态的产生问题的状态空间树，任何时候只存根到当前搜索的结点的路径。
三．实验目的和要求理解回溯法的基本原理，掌握回溯法设计的基本方法及步骤，并应用于具体问题的解决。
四．实验内容(一)马的周游问题1.问题描述在n x n棋盘（有n x n个格点的棋盘）的某个格点上有一个中国象棋马，马走日字。
求一条周游棋盘的路径，使得马能够从起始位置起沿着该路径每个格点恰好走一次最后回到出发位置。
2.具体要求用回溯法解决该问题。
输入一个正整数n，输出一个解，解的输出形式尽可能直观。
3.设计与实现代码如下：#include <iostream>#include <iomanip>#include <stdlib.h>#include <Windows.h>using namespace std;inline int good(int x,int y,int s[30][30],int n){ if(x>=0&&x<=n-1&&y>=0&&y<=n-1&&s[y][x]==88)return 1;elsereturn 0;}void main(){int flag=1;while(flag=1){cout<<endl;cout<<"1、开始求解"<<endl<<"2、退出"<<endl;cout<<endl; cout<<" 请输入您的选项(1 2) "<<endl;int cd;cout<<" 您的选项是: ";cin>>cd;switch(cd){case 1:{enum road{d11,d12,d21,d22,d31,d32,d41,d42};road d[100];int m=0;int x=0,y=0;int p=0,q=0;int s[30][30];int i,j;int w=1;int num=0;int n;cout<<" 输入棋盘的大小(不大于10):n=";cin>>n;for(i=0;i<n;++i)for(j=0;j<n;j++)s[i][j]=88;cout<<" 原始棋盘的情况"<<endl;for(i=0;i<n;i++){for(j=0;j<n;j++)cout<<s[i][j]<<" ";cout<<endl;}cout<<" 输入马在棋盘中的位置:"<<endl;cout<<"x=";cin>>p;cout<<"y=";cin>>q;p--;q--;x=p;y=q;d[0]=d11;s[y][x]=1;do{if(d[m]==d11&&good(x+1,y-2,s,n)){x++;y=y-2;d[++m]=d11;s[y][x]=++w;num++;} elseif(d[m]==d12&&good(x+2,y-1,s,n)){x=x+2;y--;d[++m]=d11;s[y][x]=++w;num++;} elseif(d[m]==d21&&good(x+2,y+1,s,n)){x=x+2;y++;d[++m]=d11;s[y][x]=++w;num++;} elseif(d[m]==d22&&good(x+1,y+2,s,n)){x++;y=y+2;d[++m]=d11;s[y][x]=++w;num++;} elseif(d[m]==d31&&good(x-1,y+2,s,n)){x--;y=y+2;d[++m]=d11;s[y][x]=++w;num++;} elseif(d[m]==d32&&good(x-2,y+1,s,n)){x=x-2;y++;d[++m]=d11;s[y][x]=++w;num++;} elseif(d[m]==d41&&good(x-2,y-1,s,n)){x=x-2;y--;d[++m]=d11;s[y][x]=++w;num++;} elseif(d[m]==d42&&good(x-1,y-2,s,n)){x--;y=y-2;d[++m]=d11;s[y][x]=++w;num++;} else{while(d[m]==d42){m--;if(d[m]==d11){s[y][x]=88;--w;x--;y=y+2;}if(d[m]==d12){s[y][x]=88;--w;x=x-2;y++;}if(d[m]==d21){s[y][x]=88;--w;x=x-2;y--;}if(d[m]==d22){s[y][x]=88;--w;x--;y=y-2;}if(d[m]==d31){s[y][x]=88;--w;x++;y=y-2;}if(d[m]==d32){s[y][x]=88;--w;x=x+2;y--;}if(d[m]==d41){s[y][x]=88;--w;x=x+2;y++;}if(m!=0&&d[m]==d42){s[y][x]=88;--w;x++;y=y+2;}}d[m]=road(d[m]+1);}}while((m!=0||d[0]!=d42||good(x-1,y-2,s,n))&&m!=n*n-1||(p-x)*(p-x) +(q-y)*(q-y)!=5);cout<<" 马跳之后的情况(数字表示跳跃先后顺序)"<<endl;for(i=0;i<n;i++){for(j=0;j<n;j++)cout<<setfill('0')<<setw(2)<<s[i][j]<<" ";cout<<endl;}cout<<endl;cout<<endl;break;}case 2:exit(1);break;default:cout<<"选择错误！请重新选择！"<<endl;break;}}}(二)寻宝问题1.问题描述对于某个m*n的字符串数组，相当于一个m行n列的平面形状的方格。
回溯法的实验报告
一、实验目的1. 理解回溯法的概念和原理；2. 掌握回溯法的基本算法设计思想；3. 通过实例验证回溯法的正确性和效率；4. 深入了解回溯法在实际问题中的应用。
二、实验内容1. 实验一：八皇后问题2. 实验二：0/1背包问题3. 实验三：数独游戏三、实验原理回溯法是一种在解空间树中搜索问题解的方法。
其基本思想是：从问题的起始状态开始，通过尝试增加约束条件，逐步增加问题的解的候选集，当候选集为空时，表示当前路径无解，则回溯到上一个状态，尝试其他的约束条件。
通过这种方法，可以找到问题的所有解，或者找到最优解。
四、实验步骤与过程1. 实验一：八皇后问题（1）问题描述：在一个8x8的国际象棋棋盘上，放置8个皇后，使得任意两个皇后都不在同一行、同一列和同一斜线上。
（2）算法设计：- 定义一个数组，用于表示棋盘上皇后的位置；- 从第一行开始，尝试将皇后放置在第一行的每一列；- 检查当前放置的皇后是否与之前的皇后冲突；- 如果没有冲突，继续将皇后放置在下一行；- 如果冲突，回溯到上一行，尝试下一列；- 重复上述步骤，直到所有皇后都放置完毕。
（3）代码实现：```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(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 col == row else '.' for col in range(len(board))]))board = [-1] 8if solve_n_queens(board, 0):print_board(board)2. 实验二：0/1背包问题（1）问题描述：给定一个背包容量为W，n件物品，每件物品的重量为w[i]，价值为v[i]，求在不超过背包容量的前提下，如何选取物品，使得总价值最大。
11121065_何锐_实验6_跳马问题
实验六、跳马问题问题描述：给定8*8方格棋盘，实验目的：求棋盘上一只马从一个位置到达另一位置的最短路径长。
算法思想：1．简单分析，说明原理或方法依旧是最短路径问题，不过此问题用回溯法来求解释比较好的。
如下：一只马在棋盘的某一点，它可以朝8个方向前进，方向向量分别是：(2,1)、(2,-1)、(1,2)、(1,-2)、(-2,1)、(-2,-1)、(-1,2)、(-1,-2)。
从中任选择一个方向前进，到达新的位置。
在从新的位置选择一个方向前进，继续，直到无法前进为止。
无法前进可能有如下原因：下一位置超出边界、下一位置已经被访问过。
当马已经无法前进时，就回退到上一位置，从新选择一个新的方向前进；如果还是无法前进，就再回退到上一位置……算法复杂度分析：在任何时刻，回溯算法只保存从根结点到当前扩展结点的路径。
如果解空间树中从根结点到叶结点的最长路径的长度为h(n)，则回溯法所需的计算空间通常为O(h(n))。
而显式地存储整个解空间则需要O(2h(n))或O(h(n)!)内存空间。
2．给出能正确运行的程序：程序代码见附录。
以下是输入输出要求以及实验结果截图：输入要求：输入有若干测试数据。
每组测试数据仅1行，每行上有2个方格pos1、pos2，之间用一个空格隔开，每格方格表示棋盘上的一个位置，该位置由表示列的1个字母（a-h）及表示行的一个数字（1-8）构成，如“d7”表示第4列第7行。
输出要求：对输入中每行上的2个方格pos1、pos2，输出马从位置pos1跳到pos2所需的最短路径长。
如“a1==>a2: 3 moves”表示从位置a1跳到a2所需的最少步数是3。
注意：按输出样例所示格式输出，如“a1==>a2: 3 moves”中冒号后有一个空格，再跟着所需的最少步数。
实验结果实验报告要求:3．设计、调试中的问题及实验体会。
回溯法，我们要知道回溯法的基本思想，以及生成问题的基本方法。
在一般情况下，用递归回溯法求解问题比较好。
回溯法
限界函数：如果（x1,x2,…,xi）是到当前E结点 的路径，那么xi的儿子结点xi+1是一 些这样的结点，它们使得 （x1,x2,…,xi,xi+1）表示没有两个皇 后正在相互攻击的一种棋盘格局。 开始状态：根结点1，表示还没有放置任何皇后。 结点的生成：依次考察皇后1——皇后n的位置。
•发现超出边界，跳法失败。
•退回A 点试跳 法2，仍失败。
马
②
马
③ ①
•再退回A点试跳法3，成功，记录新 点坐标为A2 ，保存该步出发点A的 坐标及跳法编号， 以便回溯时使用。
►然后以A2点为起点，仍按重复上述办法试探下一
步，直到达到目标状态B为止，则找到一种跳动方 法。
7
A
右上1 A2 右上1 右下2 A3 右上1 右下2 右上1 B 右上2 右下2 右下1 A4 右上2 右下1 右下1 右上2 右上2 右下1 右下2
注意：同一个问题可以有多种表示，有些表示方法更 简单，所需表示的状态空间更小（存储量少，搜索方 法简单）。
11
回溯法解决问题的一般方法
► 回溯法的基本做法是搜索（求某一解），或是一
种组织得井井有条的，能避免不必要搜索的穷举 式搜索法（求所有解）。这种方法适用于解一些 组合数相当大的问题。 ► 为了更有效的进行搜索，将所有的解构造成树的 结构，在这个解空间树中，从根结点出发按深度 优先策略搜索整个解空间树。 ► 当算法搜索至解空间树的任意一点时，先判断该 结点是否包含问题的解。如果不包含，则跳过对 该结点为根的子树的搜索，向其结点回溯；否则， 进入该子树，继续按深度优先策略搜索。
R，一旦产生了它的一个儿子C，就把C当做新的扩 展结点。在完成对子树C（以C为根的子树）的穷尽 搜索之后，将R重新变成扩展结点，继续生成R的下 一个儿子（如果存在）
中国矿业大学计算机学院算法设计与分析实验报告
算法实验报告实验一用分治法实现元素选择实验代码：#include<iostream>using namespace std;int main(){int a[100],n,x;int BinarySearch(int a[],const int&x,int n);cout<<"请输入n(n<=100):";cin>>n;cout<<"请输入n个整数:"<<endl;for(int i=0;i<n;i++){cin>>a[i];}cout<<"请输入要查找的整数x:";cin>>x;if(BinarySearch(a,x,n)!=-1)cout<<"x是数组中第"<<BinarySearch(a,x,n)+1<<"个数。
"<<endl;elsecout<<"x不是数组中的数。
"<<endl;return 0;}int BinarySearch(int a[],const int &x,int n){int left=0,right=n-1;while(left<=right){int middle=(left+right)/2;if(x==a[middle])return middle;if(x>a[middle])left=middle+1;elseright=middle-1;}return -1;}实验效果图：实验二用动态规划法求解0/1背包问题实验代码：#include <iostream>using namespace std;int main(){void Knapsack(int *v,int *w,int c,int n,int **m);void Traceback(int **m,int *w,int c,int n,int *x);int v[100],w[100],n,c,**m,x[100],i;m=new int *[100];for(i=0;i<100;i++)m[i]=new int[100];cout<<"请输入物品个数n:";cin>>n;cout<<"请输入背包容量c:";cin>>c;cout<<"请分别输入每个物品的价值:"<<endl;for(i=1;i<=n;i++)cin>>v[i];cout<<"请分别输入每个物品的重量:"<<endl;for(i=1;i<=n;i++)cin>>w[i];Knapsack(v,w,c,n,m);Traceback(m,w,c,n,x);cout<<"最优解为："<<endl;for(i=1;i<=n;i++)cout<<x[i]<<' ';cout<<endl;return 0;}int min(int a,int b){if(a>b)return b;elsereturn a;}int max(int a,int b){if(a>b)return a;elsereturn b;}void Knapsack(int *v,int *w,int c,int n,int **m) {int i,j;int jMax=min(w[n]-1,c);for(j=0;j<=jMax;j++)m[n][j]=0;for(j=w[n];j<=c;j++)m[n][j]=v[n];for(i=n-1;i>1;i--){jMax=min(w[i]-1,c);for(j=0;j<=jMax;j++)m[i][j]=m[i+1][j];for(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];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;else{x[i]=1;c-=w[i];}x[n]=(m[n][c])?1:0;}}实验效果图：实验三用贪心算法求解最小生成树实验代码：#include <iostream>#define inf 10000#define max 50void prim(int g[max][max],int n){int lowcost[max],closest[max];int i,j,k,min;bool s[max];s[1]=true;for(i=2;i<=n;i++){lowcost[i]=g[1][i];closest[i]=1;s[i]=false;}for(i=1;i<n;i++){min=inf;j=1;for(k=2;k<=n;k++)if((lowcost[k]<min)&&(!s[k])){min=lowcost[k];j=k;}printf("(%d, %d), %d\t",closest[j],j,min);s[j]=true;for(k=2;k<=n;k++)if((g[j][k]<lowcost[k])&&(!s[k])){lowcost[k]=g[j][k];closest[k]=j;}printf("\n");}}void main(){int g[max][max];int n,i,j;printf("结点数为:");scanf("%d",&n);printf("请输入点之间权重：\n");for(i=1;i<=n;i++)for(j=i+1;j<=n;j++ ){printf("%d %d :",i,j);scanf("%d",&g[i][j]);}for(i=n;i>=1;i--)for(j=i-1;j>=1;j--)g[i][j]=g[j][i];printf("最小生成树为:\n");prim(g,n);}实验效果图：实验四用回溯法求解跳马问题实验代码：//起始位置：0,0#include <iostream>using namespace std;int M,N;int map[100][100];int count=0; //记录马共跳的步数int countnum=0; //用于统计走法种数int direction[8][2]={{1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2}};//马可能前进的8个方向int flag=0;void print_map(){int t=0;for(int i=0;i<M;i++){for(int j=0;j<N;j++){cout<<map[i][j]<<"\t";t++;if(t==M){cout<<endl;t=0;}}};countnum=countnum+1;cout<<countnum<<":"<<endl;}void go(int i,int j){//改变标志位，环境变量等等：这些改变就相当于完成一步动作，在跳马问题中就是马向前跳一步count++; //计数器map[i][j]=count; //棋盘置当前步数//如果找到匹配的，则输出结果if(count==M*N) //如果已经遍历棋盘则打印一次走法{print_map();flag=1;}//否则，找到当前步可能的路径即进行下一步动作；这里可能有多个分支，如跳马问题中马可以往八个方向跳，每个分支都要列举出来，以便回溯时使用 else if(flag==0){int m,n;for (int k=0;k<8;k++){m=i+direction[k][0];n=j+direction[k][1];if(m>=0 && m<M && n>=0 && n<N)if(map[m][n]==0){go(m,n);}}}//回退：还原标志位，环境变量等map[i][j]=0;//回退，置零count--;//计数器减}int main(){cout<<"请输入棋盘大小N:";cin>>N;M=N;for(int k=0;k<M;k++)for(int l=0;l<N;l++)map[k][l]=0;go(0,0);return 0;}实验效果图：附加题：1、棋盘覆盖问题实验代码：#include<iomanip.h>#include<iostream.h>#include<stdlib.h>int tile=0; //定义全局变量tile表示L型骨牌编号int **chessarr; //定义全局变量chessarr表示棋盘数组void chessboard(int row0,int col0,int size,int sprow,int spcol);// 棋盘覆盖函数// row0,col0为棋盘左上角位置，sprow,spcol为特殊方格位置// size为棋盘规模void chessboard(int row0,int col0,int size,int sprow,int spcol) //棋盘覆盖函数{if(size==1) return; //如果棋盘规模=1，返回int s=size/2; //分割棋盘int t=++tile; //L型骨牌编号加1//处理左上角子棋盘if(sprow < row0+s && spcol < col0+s)chessboard(row0,col0,s,sprow,spcol);else{chessarr[row0+s-1][col0+s-1]=t;chessboard(row0,col0,s,row0+s-1,col0+s-1);}//处理右上角子棋盘if(sprow < row0+s && spcol >= col0+s)chessboard(row0,col0+s,s,sprow,spcol);else{chessarr[row0+s-1][col0+s]=t;chessboard(row0,col0+s,s,row0+s-1,col0+s);}//处理左下角子棋盘if(sprow >= row0+s && spcol < col0+s)chessboard(row0+s,col0,s,sprow,spcol);else{chessarr[row0+s][col0+s-1]=t;chessboard(row0+s,col0,s,row0+s,col0+s-1);}//处理右下角子棋盘if(sprow >= row0+s && spcol >= col0+s)chessboard(row0+s,col0+s,s,sprow,spcol);else{chessarr[row0+s][col0+s]=t;chessboard(row0+s,col0+s,s,row0+s,col0+s);}}void main(){int k,x,y; //阶数及特殊点位置int i,j,n; //棋盘规模为n*ncout<<"请输入棋盘的阶数：";cin>>k;cout<<"请输入特殊点的位置(从1开始)：";cin>>x>>y;for (i=0,n=1;i<k;i++)n*=2;//在堆内存中建立棋盘数组，填充特殊方格if((chessarr=new int*[n])==NULL){cout << "Can't allocate more memory,terminating." << endl;exit (1);}for (i=0;i<n;i++ ){if((chessarr[i]=new int[n])==NULL){cout << "Can't allocate more memory,terminating." << endl;exit (1);}}chessarr[x-1][y-1]=0; // 填写特殊方格tile=0;chessboard(0,0,n,x-1,y-1);//进行棋盘覆盖,左上角位置0,0; 棋盘宽度n; 特殊点x,y for (i=0;i<n;i++){for (j=0;j<n;j++ ){cout << setw(5) << chessarr[i][j];}cout << endl;}//释放内存for(i=0;i<n;i++)delete[] chessarr[i];delete[] chessarr;return;}实验效果图：2、双色hanoi塔问题实验代码：#include <iostream>using namespace std;int main(){void hanoi(int,char,char,char);int m;cin>>m;hanoi(m,'A','B','C');return 0;}void hanoi(int n,char a,char b,char c){void move(int,char,char);if(n==1)move(n,a,b);else{hanoi(n-1,a,c,b);move(n,a,b);hanoi(n-1,c,b,a);}}void move(int n,char x,char y) {cout<<n<<""<<x<<y<<endl;}实验效果图：。
跳马问题中存在的多种算法思想
跳马问题中存在的多种算法思想作者：邓立波来源：《中国信息技术教育》2012年第01期在信息量飞速增长的现代社会中，如何有效地获取和处理信息已成了信息技术教师面对的课题之一。
如何有条理地分析各种问题中的有用数据，发现数据的变化规律，制订相应的处理方法，构建解决整个问题的流程，也成了教师们的日常工作之一。
众所周知，计算机的特征是运算速度快、精度高，在精确的控制之下，一切都会按部就班地执行，从而提高效率。
如果我们能很好地利用计算机这个工具，那么我们就只需做个规划者，而繁琐的处理过程就可以留给计算机来执行。
下面我就以对一个问题的分析来说明流程控制中的多样性。
问题描述：设一个m*n的棋盘，在棋盘上左下角的A点（0，0）有一个中国象棋的马，并约定马走的规则是：①马走日字；②马只能向右走。
任务：编程读入m,n，请打印出一条从A（0，0）到B（m，n）的路径。
跳马问题也称为骑士遍历问题，是一道非常古老的题目了，好多人在讲回溯算法时都喜欢用到这个例子，因为这是适合用回溯法解决的一个经典例子，它仅用一张平面表格就把阶段、状态、决策等因素直观而又抽象地展现在人们面前。
但我们不希望仅以一道或几道经典题目，让学生掌握一种算法，而是从不同的角度、方向来分析当前这种变化规则，找到适合的方法来处理目前这种变化，从而提高学生的解题适应能力。
● 回溯法适用于解决多阶段决策问题中求单路径、全路径等用回溯法解决跳马问题的基本思想是从起点开始每一步先作出选择，再判断，再跨出到下一步，重复上述过程，每一步的跨出都会离目的地越来越近，但当到不了目的地时，回退一步，如果可以作出新的选择，则重新跨出，否则再退，以此类推。
上述过程可以借助于图形进行模拟，让学生先清楚整个过程。
接下来便是每一步骤的语言描述及控制。
其中每一步所做出的选择必须记录，否则回退时不能做出新的选择。
求单路径的流程图如下：参考程序：program knight1;const dx:array[1..4] of integer=(1,2,2,1);dy:array[1..4] of integer=(-2,-1,1,2);max=1000;var x,y,m,k,i,mm,nn:integer;b:array[0..max] of integer;beginwrite('input m,n:');readln(mm,nn);x:=0;y:=0;m:=0;k:=0;for i:=0 to max do b[i]:=0;while (xmm) or (ynn) do {目标点为(mm，nn)}begink:=k+1; {找个方向}if k>4 then begin k:=b[m]; {没有方向可跳，则回溯} m:=m-1;x:=x-dx[k];y:=y-dy[k];endelseif (x+dx[k]=0) or (y+dy[k]begin {继续往下跳}m:=m+1;b[m]:=k;k:=0;end;end;for i:=1 to m do write(b[i]:9); {输出每步的方向}writeln;x:=0;y:=0; {输出路径}write('(0,0)--->');for i:=1 to m dobeginx:=x+dx[b[i]];y:=y+dy[b[i]];if im then write('(',x,',',y,')','--->')else writeln('(',x,',',y,')');end;readln;end.以上是求从起点到终点的一条路径，这是一种能深入先深入，否则回退，换条路走的思维方式，即深度优先搜索。
回溯算法的应用
回溯算法的应用课程名称：算法设计与分析院系：************************学生姓名：******学号：************专业班级：***************************** 指导教师：******2013年12月27日回溯法的应用摘要：回溯法（探索与回溯法）是一种选优搜索法，按选优条件向前搜索，以达到目标。
但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。
回溯法，其意义是在递归直到可解的最小问题后，逐步返回原问题的过程。
而这里所说的回溯算法实际是一个类似枚举的搜索尝试方法，它的主题思想是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。
回溯算法是尝试搜索算法中最为基本的一种算法，其采用了一种“走不通就掉头”的思想，作为其控制结构。
在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。
当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。
若用回溯法求问题的所有解时，要回溯到根，且根结点的所有可行的子树都要已被搜索遍才结束。
而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。
全排列和求最优解问题是比较经典的问题，我们可以采用多种算法去求解此问题，比如动态规划法、分支限界法、回溯法。
在这里我们采用回溯法来解决这个问题。
关键词：回溯法全排列最优值枚举目录第1章绪论 (4)1.1 回溯法的背景知识 (4)1.2 回溯法的前景意义 (4)第2章回溯法的理论知识 (5)2.1 问题的解空间树 (5)2.2 回溯法的一般性描述 (6)第3章 n的全排列 (7)3.1 问题描述 (7)3.2 问题分析 (7)3.3 算法设计 (7)3.4 测试结果与分析 (9)第4章最优化问题 (11)4.1 问题描述 (11)4.2 问题分析 (11)4.3 算法设计 (11)4.4 测试结果与分析 (14)第5章结论 (15)参考文献 (16)附件 (16)第1章绪论1.1 回溯法的背景知识回溯算法是尝试搜索算法中最为基本的一种算法，其采用了一种“走不通就掉头”的思想，作为其控制结构。
实验四 回溯法的应用------跳马算法
实验四回溯法的应用------跳马算法学号：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;}四、心得体会这程序和以前做的迷宫问题很相象，写起来不是很困难. 确定限界函数，在只有满足限界函数的前提下得到解，不满足限界条件时就要回溯，回到上一个节点，再从另外的方向出发。
跳马问题
跳马问题算法代码跳马问题也称骑士遍历问题：在6*6方格的棋盘上，从任意指定的方格出发，为象棋中的马寻找一条走遍棋盘每一格并且只经过一次的一条路径。
(跳马问题采用回溯法求解最多只能求到6*6，当棋盘再大时采用回溯法无法求出答案。
复杂度太大，计算机承受不了。
当M*N的棋盘时，若M*N 是奇数，则一定无解)【算法描述】本题有较多方法求解，在此仅对回溯法进行分析。
一只马在棋盘的某一点，它可以朝8个方向前进，方向向量分别是：(2,1)、(2,-1)、(1,2)、(1,-2)、(-2,1)、(-2,-1)、(-1,2)、(-1,-2)。
从中任选择一个方向前进，到达新的位置。
在从新的位置选择一个方向前进，继续，直到无法前进为止。
无法前进可能有如下原因：下一位置超出边界、下一位置已经被访问过。
当马已经无法前进时，就回退到上一位置，从新选择一个新的方向前进；如果还是无法前进，就再回退到上一位置……#include<iostream.h>#include <time.h>#include <stdlib.h>const int n=6; // 表示棋盘的长和高nint qiban[n+1][n+1]; // 记录棋盘是否被跳过static int cmq; // 步数int con=1,OK=0; // 没有被使用int xLabel,yLabel;void shuchu(){cout<<'\t';for(int i1=1;i1<=n;i1++)cout<<i1<<"列"<<'\t';for(int i=1;i<=n;i++){cout<<endl;cout<<i<<"行"<<'\t';for(int j=1;j<=n;j++){cout<<qiban[i][j]<<'\t';}cout<<endl;}}int tiaoma(int x,int y){if(cmq ==n*n && ((x-2==xLabel && y+1 == yLabel) ||(x-1==xLabel && y+2 == yLabel) ||(x+1==xLabel && y+2== yLabel) || (x+2 == xLabel && y+1 == yLabel) ||(x+2 == xLabel && y-1 == yLabel) ||(x+1== xLabel && y-2==yLabel) ||(x-2==xLabel && y-1==yLabel) ||(x-1==xLabel && y-2==yLabel))){shuchu();OK=1;return 0;}if(1 <= x-2 && y+1 <= n && qiban[x-2][y+1] == 0){qiban[x-2][y+1]=++cmq;// 1tiaoma(x-2,y+1);if(1<=x-1&&y+2<=n&&qiban[x-1][y+2]==0) {qiban[x-1][y+2]=++cmq;// 2tiaoma(x-1,y+2);}if(x+1<=n&&y+2<=n&&qiban[x+1][y+2]==0) {qiban[x+1][y+2]=++cmq;// 3tiaoma(x+1,y+2);}if(x+2<=n&&y+1<=n&&qiban[x+2][y+1]==0) {qiban[x+2][y+1]=++cmq;// 4tiaoma(x+2,y+1);}if(x+2<=n&&1<=y-1&&qiban[x+2][y-1]==0) {qiban[x+2][y-1]=++cmq;// 5tiaoma(x+2,y-1);}if(x+1<=n&&1<=y-2&&qiban[x+1][y-2]==0)qiban[x+1][y-2]=++cmq;// 6tiaoma(x+1,y-2);}if(1<=x-1&&1<=y-2&&qiban[x-1][y-2]==0) {qiban[x-1][y-2]=++cmq;// 7tiaoma(x-1,y-2);}if(1<=x-2&&1<=y-1&&qiban[x-2][y-1]==0) {qiban[x-2][y-1]=++cmq;// 8tiaoma(x-2,y-1);}cmq --;qiban[x][y] = 0;// 回朔return 0;}int main(){unsigned beg,end;beg=(unsigned)time(NULL);for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)qiban[i][j]=0;for(i=1;i<=n;i++) //该处分别计算从点(1,1)到点(n,n)作为起始点，可以找到哪些回路for(int j=1;j<=n;j++){xLabel= i;yLabel = j;cmq = 1;for(int k1=1;k1<=n;k1++)for(int k2=1;k2<=n;k2++)qiban[k1][k2]=0;qiban[i][j] = 1;tiaoma(i,j);}if(OK!=1){cout<<endl<<"当n＝"<<n<<"时无回路"<<endl;}end=(unsigned)time(NULL);cout<<end-beg << "s .";return 0;}回溯法其实也是一种穷举的方法，因此在进行递归调用时，一定要先判断下一步动作是否满足条件，这样可以减少递归次数。
跳马问题回溯法
跳马问题回溯法全文共四篇示例，供读者参考第一篇示例：跳马问题是一个经典的数学问题，也是一个很好的回溯法的练习题。
跳马问题是指在一个棋盘上，给定一个起始位置和一个目标位置，棋盘上只能按照马跳的规则（即按照国际象棋中马的行走规则）进行移动，问是否能够从起始位置跳到目标位置。
这个问题看似简单，但实际上需要一定的技巧和思考。
回溯法是一种解决问题的方法，它通过逐步构建解空间树并在搜索过程中剪枝，从而找到问题的解。
在解决跳马问题时，回溯法可以帮助我们搜索所有可能的跳法，找到可以到达目标位置的路径。
我们需要定义一些重要的概念。
在国际象棋中，马可以按照以下规则进行移动：以当前位置为中心，向八个方向中的一个方向跳两步，再沿着90度角的一个方向跳一步，即“日”字形。
在跳马问题中，我们可以用一个二维数组来表示棋盘，每个位置用一个数字来表示，表示该位置被访问的次序；用一个二维数组来存储马的移动规则；用一个二维数组来存储每一步的移动路径。
接下来，我们可以编写一个函数来实现跳马的逻辑。
我们需要判断当前位置是否合法，即在棋盘范围内且未被访问过；然后，我们需要判断是否已经到达目标位置，如果是，则返回true；否则，我们尝试按照马的移动规则进行递归搜索。
在搜索的过程中，我们可以记录已经访问过的位置，并在遇到无法移动的情况下进行回溯。
通过不断递归搜索，我们可以找到所有可能的路径，并判断是否存在一条路径能够到达目标位置。
这就是回溯法在解决跳马问题中的应用。
跳马问题是一个经典的数学问题，通过回溯法可以很好地解决。
回溯法是一种非常重要的解决问题的方法，可以帮助我们在搜索过程中不断调整搜索空间，并找到问题的最优解。
希望通过这篇文章的介绍，你能更好地理解跳马问题和回溯法的应用。
愿你在学习和探索中不断进步，解决更多有趣的问题！第二篇示例：跳马问题是一个经典的数学问题，它需要运用回溯法来解决。
跳马问题源于国际象棋中的一种走法，即马的走法。
马每次走日字形，即向前走两步，然后向左或向右一步，或者向前走一步，然后向左或向右两步。
跳马问题骑士遍历问题
❖ int tiaoma(int x,int y) ❖{ ❖ if(cmq ==n*n && ((x-2==xLabel && y+1 == yLabel) ||(x-1==xLabel && y+2 == yLabel) ||(x+1==xLabel
&& y+2== yLabel) || (x+2 == xLabel && y+1 == yLabel) ||(x+2 == xLabel && y-1 == yLabel) ||(x+1== xLabel && y-2==yLabel) ||(x-2==xLabel && y-1==yLabel) ||(x-1==xLabel && y-2==yLabel))) ❖{ ❖ shuchu(); ❖ OK=1; ❖ return 0; ❖}
❖ tiaoma(x+1,y-2);
❖}
❖ if(1<=x-1&&1<=y-2&&qipan[x-1][y-2]==0)
❖{
❖ qipan[x-1][y-2]=++cmq; // 7
❖ tiaoma(x-1,y-2);
❖}
❖ if(1<=x-2&&1<=y-1&&qipan[x-2][y-1]==0)
❖ int qipan[n+1][n+1]; // 统计棋盘是否被跳过
❖ static int cmq;
// 步数
❖ int OK=0; // 没有被使用
回溯法实验报告
回溯法实验报告实验04 回溯法班级：0920561 姓名：宋建俭学号：20一、实验目的1.掌握回溯法的基本思想。
2.掌握回溯法中问题的解空间、解向量、显式约束条件、隐式约束条件以及子集树与排列树的递归算法结构等内容。
3.掌握回溯法求解具体问题的方法。
二、实验要求1.认真阅读算法设计教材,了解回溯法思想及方法;2.设计用回溯算法求解装载问题、n后问题、图的m着色问题的java程序三、实验内容1.有一批共n个集装箱要装上2艘载重量分别为C1和C2的轮船，其中集装箱i的重量为wi，且∑wi≤C1+C2。
装载问题要求确定是否有一个合理的装载方案可将这个集装箱装上这2艘轮船。
如果有，找出一种装载方案。
2.在n×n格的棋盘上放置彼此不受攻击的n个皇后。
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n后问题等价于在n×n格的棋盘上放置n个皇后，任何2个皇后不放在同一行或同一列或同一斜线上。
3.给定无向连通图G和m种不同的颜色。
用这些颜色为图G的各顶点着色，每个顶点着一种颜色。
是否有一种着色法使G中每条边的2个顶点着不同颜色。
这个问题是图的m可着色判定问题。
四、算法原理1、装载问题用回溯法解装载问题时，用子集树表示其解空间是最合适的。
可行性约束可剪去不满足约束条件(w1x1+w2x2+…+wnxn)<=c1的子树。
在子集树的第j+1层结点Z处，用cw记当前的装载重量，即cw=(w1x1+w2x2+…+wjxj)，当cw>c1时，以结点Z为根的子树中所有结点都不满足约束条件，因而该子树中的解均为不可行解，故可将该子树剪去。
解装载问题的回溯法中，方法maxLoading返回不超过c的最大子集和，但未给出达到这个最大子集和的相应子集。
算法maxLoading调用递归方法backtrack(1)实现回溯搜索。
Backtrack(i)搜索子集树中第i层子树。
类Loading的数据成员记录子集树结点信息，以减少传给backtrack的参数。
回溯与分支限界算法设计
算法设计与分析实验报告1.骑士游历问题（采用回溯法）：在国际象棋的棋盘（8行×8列）上放置一个马，按照“马走日字”的规则，马要遍历棋盘，即到达棋盘上的每一格，并且每格只到达一次。
若给定起始位置（x0,y0）,编程探索出一条路径，沿着这条路径马能遍历棋盘上的所有单元格。
2. 行列变换问题（采用分支限界法）：给定两个m n方格阵列组成的图形A和图形B，每个方格的颜色为黑色或白色，如下图所示。
行列变换问题的每一步变换可以交换任意2行或2列方格的颜色，或者将某行或某列颠倒。
上述每次变换算作一步。
试设计一个算法，计算最少需要多少步，才能将图形A变换为图形B。
图形A图形B2. 行列变换问题的程序：package .t8;import java.util.LinkedList;import java.util.Scanner;class 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){this.x=x;}int getx(){return this.x;}void rowx(){//将一个整数划分成四行二进制int y;for(int i=0;i<m;i++){y=1;row[i]=0;for(int j=0;j<n;j++){if((x&1)!=0) //如果x的最低位是1row[i]|=y;y<<=1;x>>=1;}}}}实例：总结实验心得体会：掌握回溯法解决问题的一般步骤。
学会使用回溯法解决实际问题。
掌握分支限界法解决问题的基本思想。
回溯算法
三、回溯的一般步骤
回溯法正是针对这类问题，利用这类问题的
上述性质而提出来的比枚举法效率更高的算 法。
二、回溯的一般描述
procedure rbacktrack(k); begin if k > n then return else for each x(k)，如果x(k)∈t(x(1)…x(k-1))且 b(x(1)…x(k))=true do begin if x(1)…x(k)是一个解 then write(x(1)…x(k) else rbacktrack(k+1); end; end;
演示
一、回溯的概念
像走迷宫这样，遇到死路就回头的搜索思路
就叫做“回溯”。
从问题的某种可能情况出发，搜索所有能到
达的可能情况，然后以其中一种可能的情况 为新的出发点，继续向下探索，当所有可能 情况都探索过且都无法到达目标的时候，再 回退到上一个出发点，继续探索另一个可能 情况，这种不断回头寻找目标的方法称为 “回溯法”。
二、回溯的一般描述
可用回溯法求解的问题P，通常要能表达为：
对于已知的由n元组（x1，x2，…，xn）组成 的一个状态空间E={（x1，x2，…，xn） ∣xi∈Si ，i=1，2，…，n}，给定关于n元组 中的一个分量的一个约束集D，要求E中满足 D的全部约束条件的所有n元组。其中Si是分 量xi的定义域，且 |Si| 有限，i=1，2，…， n。我们称E中满足D的全部约束条件的任一 n元组为问题P的一个解。
骑士遍历
骑士遍历问题的解空间是从左下角到右上角
node、扩展节点）。 从E-节点可移动到一个新节点。 如果能从当前的E-节点移动到一个新节点，那么这个新 节点将变成一个活节点和新的E-节点，旧的E-节点仍是 一个活节点。 如果不能移到一个新节点，当前的E-节点就“死”了 （即不再是一个活节点），那么便只能返回到最近被考 察的活节点（回溯），这个活节点变成了新的E-节点。 当我们已经找到了答案或者回溯尽了所有的活节点时， 搜索过程结束。
回溯算法原理和几个常用的算法实例
回溯算法思想：回溯（backtracking）是一种系统地搜索问题解答的方法。
为了实现回溯，首先需要为问题定义一个解空间（solution space），这个空间必须至少包含问题的一个解（可能是最优的）。
下一步是组织解空间以便它能被容易地搜索。
典型的组织方法是图(迷宫问题)或树(N皇后问题)。
一旦定义了解空间的组织方法，这个空间即可按深度优先的方法从开始节点进行搜索。
回溯方法的步骤如下：1) 定义一个解空间，它包含问题的解。
2) 用适于搜索的方式组织该空间。
3) 用深度优先法搜索该空间，利用限界函数避免移动到不可能产生解的子空间。
回溯算法的一个有趣的特性是在搜索执行的同时产生解空间。
在搜索期间的任何时刻，仅保留从开始节点到当前节点的路径。
因此，回溯算法的空间需求为O （从开始节点起最长路径的长度）。
这个特性非常重要，因为解空间的大小通常是最长路径长度的指数或阶乘。
所以如果要存储全部解空间的话，再多的空间也不够用。
算法应用：回溯算法的求解过程实质上是一个先序遍历一棵"状态树"的过程,只是这棵树不是遍历前预先建立的,而是隐含在遍历过程中。
(1) 幂集问题(组合问题)(参见《数据结构》（严蔚敏）)求含N个元素的集合的幂集。
如对于集合A={1,2,3},则A的幂集为p(A)={{1,2,3},{1,2},{1,3},{1},{2,3},{2},{3},Φ}幂集的每个元素是一个集合，它或是空集，或含集合A中的一个元素，或含A 中的两个元素，或者等于集合A。
反之，集合A中的每一个元素，它只有两种状态：属于幂集的元素集，或不属于幂集元素集。
则求幂集P（A）的元素的过程可看成是依次对集合A中元素进行“取”或“舍”的过程，并且可以用一棵状态树来表示。
求幂集元素的过程即为先序遍历这棵状态树的过程。
程序：#include <stdio.h>#include <malloc.h>#define ERROR 0#define OK 1typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;//初始化LinkList ListInit(){LNode *base=(LinkList)malloc(sizeof(LNode)); base->data=0;base->next=NULL;return base;}//插入一个元素int ListInsert(LinkList L,int i,ElemType e){LNode *p,*s;int j=0;p=(LNode *)L;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)return ERROR;s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}//删除一个结点int ListDelete(LinkList &L,int i,ElemType &e) {LinkList p=L,q;int j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);}//长度int ListLength(LinkList L){LinkList p=L;int j=0;if(!L)return ERROR;while(p->next){p=p->next;++j;}return j;}//查找一个元素int GetElem(LinkList L,int i,ElemType &e) {LNode *p=L;int j=0;while(p->next&&j<i){p=p->next;++j;}if(!p||j>i)return ERROR;e=p->data;return OK;}//输出链表元素void Display(LinkList L){LNode *p=L;if(!(p->next)){printf("NULL,");return;}elsep=p->next;while(p){printf("%d,",p->data);p=p->next;}}//求幂集void PowerSet(int i,LinkList A,LinkList &B) {int k=0;ElemType e=0;if(i>ListLength(A)){Display(B);printf("\n");}else{GetElem(A,i,e);k=ListLength(B);ListInsert(B,k+1,e);PowerSet(i+1,A,B);ListDelete(B,k+1,e);PowerSet(i+1,A,B);}}int main(){LinkList list=ListInit(); //初始化LinkList list2=ListInit();//初始化ListInsert(list,1,1);//插入元素ListInsert(list,2,2);ListInsert(list,3,3);Display(list);//输出元素printf("\npower set is:\n");PowerSet(1,list,list2);//求幂集}(2)迷宫问题(参见《数据结构》（严蔚敏）)计算机解迷宫时，通常用的是"试探和回溯"的方法，即从入口出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路退回，换一个方向再继续探索，直至所有可能的通路都探索到为止,如果所有可能的通路都试探过，还是不能走到终点，那就说明该迷宫不存在从起点到终点的通道。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四回溯法的应用------跳马算法
学号：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]];
}//for
sort1(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
}//for
kp--;//回朔
}//search
int 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");
}//while
return 0;
}
四、心得体会
这程序和以前做的迷宫问题很相象，写起来不是很困难. 确定限界函数，在只有满足限界函数的前提下得到解，不满足限界条件时就要回溯，回到上一个节点，再从另外的方向出发。
这我得到的回溯法的思想和思路。