回溯法实验报告
回溯法实验(图的m着色问题)
算法分析与设计实验报告第六次附加实验cout<<endl;}elsefor(int i=1;i<=m;i++){x[t]=i;if(ok(t)) Backtrack(t+1);//回溯，继续寻找下一层x[t]=0;//回到最初状态，使x[1]继续尝试其他填色的可能解}}测试结果当输入图如下时：结果如下：12435只要输入边即可当输入的图如下时：结果如下：附录：完整代码（回溯法）//图的m着色问题回溯法求解#include<iostream>using namespace std;class Color{friend void mColoring(int,int,int **);private:bool ok(int k);void Backtrack(int t);int n, //图的顶点个数m, //可用颜色数**a, //图的邻接矩阵*x; //当前解long sum; //当前已找到的可m着色的方案数};bool Color::ok(int k) //检查颜色可用性{for(int j=1;j<=n;j++)if((a[k][j]==1)&&(x[j]==x[k])) //两个点之间有约束且颜色相同return false;return true;}void Color::Backtrack(int t){if(t>n) //到达叶子节点{sum++; //可行解+1cout<<"着色： ";for(int i=1;i<=n;i++) //输出可行解方案cout<<x[i]<<" ";cout<<endl;}elsefor(int i=1;i<=m;i++){x[t]=i;if(ok(t)) Backtrack(t+1);//回溯，继续寻找下一层x[t]=0;//回到最初状态，使x[1]继续尝试其他填色的可能解 }}void mColoring(int n,int m,int **a){Color X;//初始化XX.n=n;X.m=m;X.a=a;X.sum=0;int *p=new int[n+1];for(int i=0;i<=n;i++)p[i]=0;X.x=p;cout<<"顶点： ";for(int i=1;i<=n;i++) //用于输出结果cout<<i<<" " ;cout<<endl;X.Backtrack(1); //从顶点1开始回溯delete []p;cout<<"解法个数："<<X.sum<<endl;}int main(){int n;int m;cout<<"please input number of node:";cin>>n;cout<<"please input number of color:";cin>>m;int **a=new int*[n+1];for(int i=0;i<=n;i++)a[i]=new int[n+1];for(int i=0;i<=n;i++) //利用抽象图实现图的邻接矩阵for(int j=0;j<=n;j++)a[i][j]=0;int edge;cout<<"please input adjacent edge number:";cin>>edge;int v,w;cout<<"please inout adjacent edge:"<<endl; //只要输入边即可for(int i=0;i<edge;i++){cin>>v>>w; //由于是无向图，所以对应的邻接矩阵对应的边都有，即v->m,m->v都有边a[v][w]=1;a[w][v]=1;}mColoring(n,m,a);system("pause");return 0;}。
回溯法实验(n皇后问题)(迭代法)
算法分析与设计实验报告第三次附加实验附录：完整代码（回溯法）//回溯算法递归回溯n皇后问题#include<iostream>#include<time.h>#include<iomanip>#include"math.h"using namespace std;class Queen{friend int nQueen(int); //定义友元函数，可以访问私有数据private:bool Place(int k); //判断该位置是否可用的函数void Backtrack(int t); //定义回溯函数int n; //皇后个数int *x; //当前解long sum; //当前已找到的可行方案数};int main(){int m,n;for(int i=1;i<=1;i++){cout<<"请输入皇后的个数："; //输入皇后个数cin>>n;cout<<"皇后问题的解为："<<endl;clock_t start,end,over; //计算程序运行时间的算法start=clock();end=clock();over=end-start;start=clock();m=nQueen(n); //调用求解的函数cout<<n<<"皇后问题共有";cout<<m<<"个不同的解！"<<endl; //输出结果end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显示运行时间cout<<endl;}system("pause");return 0;}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){sum++;/*for(int i=1;i<=n;i++) //输出皇后排列的解{cout<<x[i]<<" ";}cout<<endl;*/}else{//回溯探索第i行的每一列是否有元素满足要求for(int i=1;i<=n;i++){x[t]=i;if(Place(t)){Backtrack(t+1);}}}}int nQueen(int n){Queen X; //定义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;//输出解的个数}完整代码（回溯法）//回溯算法迭代回溯n皇后问题#include<iostream>#include<time.h>#include<iomanip>#include"math.h"using namespace std;class Queen{friend int nQueen(int); //定义友元函数private:bool Place(int k); //定义位置是否可用的判断函数void Backtrack(void); //定义回溯函数int n; // 皇后个数int *x; // 当前解long sum; // 当前已找到的可行方案数};int main(){int n,m;for(int i=1;i<=1;i++){cout<<"请输入皇后的个数：";cin>>n;cout<<n<<"皇后问题的解为："<<endl;clock_t start,end,over; //计算程序运行时间的算法start=clock();end=clock();over=end-start;start=clock();m=nQueen(n); //调用求解皇后问题的函数cout<<n<<"皇后问题共有";cout<<m<<"个不同的解!"<<endl;end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显示运行时间cout<<endl;}system("pause");return 0;}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() //迭代法实现回溯函数{x[1] = 0;int k = 1;while(k>0){x[k] += 1; //先将皇后放在第一列的位置上while((x[k]<=n)&&!(Place(k))) //寻找能够放置皇后的位置{x[k] += 1;}if(x[k]<=n) //找到位置{if(k == n) //如果寻找结束输出结果{/*for (int i=1;i<=n;i++){cout<<x[i]<<" ";}cout<<endl; */sum++;}else//没有结束则找下一行{k++;x[k]=0;}}else//没有找到合适的位置则回溯{ k--; }}}int nQueen(int n){Queen X; //定义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();delete []p;return X.sum; //返回不同解的个数}。
回溯法的实验报告
一、实验目的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]，求在不超过背包容量的前提下，如何选取物品，使得总价值最大。
回朔法实验报告
一、实验目的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）在实验过程中，需要合理设计回溯法函数，以提高算法的效率。
五、实验总结通过本次实验，我们了解了回溯法的基本原理和适用场景，掌握了回溯法在解决实际问题中的应用。
在实验过程中，我们提高了编程能力和算法设计能力，为今后解决类似问题奠定了基础。
在今后的学习和工作中，我们将继续深入研究回溯法及其应用，以期为解决实际问题提供更多思路和方法。
算法分析与设计实验报告--回溯法
算法分析与设计实验报告--回溯法实验目的：通过本次实验，掌握回溯法的基本原理和应用，能够设计出回溯法算法解决实际问题。
实验内容：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]]```本次实验通过实现回溯法求解八皇后问题，掌握了回溯法的基本原理和应用，并对回溯法的核心思想进行了深入理解。
回溯法求哈密尔顿回路试验报告
回溯法求哈密尔顿回路2014211053谭富林一.实验目的和算法分析试验目的：通过回溯的方法找出图的一般哈密顿尔回路，并且能够输出结果。
算法分析：回溯法是一个既带有系统性又带有跳跃性的的搜索算法。
它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。
算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。
如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。
否则，进入该子树，继续按深度优先的策略进行搜索。
回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。
而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。
这种以深度优先的方式系统地搜索问题的解的算法称为回溯法，它适用于解一些组合数较大的问题。
哈密顿回路是从某顶点开始，经过图全部顶点一次回到起点的回路。
二.实验内容1.编写实现算法：给定n点，m条变，找出所有哈密尔顿回路。
2.将输出数据显示在控制台窗体中。
3.对实验结果进行分析。
三.实验开发工具操作系统：windows8开发工具:Microsoft visual studio 2010开发语言:C++四.实验操作程序的思路：程序的实现：#include<stdio.h>#include<process.h>#include<math.h>//全局变量声明int m=1; //用于标志哈密尔顿回路的总个数int n; //int x[128];int graph[128][128];void nextvalue(int k){int j;while(1){x[k]=(x[k]+1)%(n+1);if(x[k]==0) return;if(graph[x[k-1]][x[k]]){for(j=1;j<=k-1;j++){if(x[j]==x[k]) break;}if(j==k){if(k<n||(k==n&&graph[x[n]][1]))return;}}}}void print(int x[],int n){int i=1;printf("回路%d:",m);for(;i<=n;i++)printf("%d ",x[i]);printf("\n");m++;}void hamiltonian(int k){while(1){nextvalue(k);if(x[k]==0) return;if(k==n)print(x,n);elsehamiltonian(k+1);}}void main(){int i,j,e,a,b;printf("***********哈密顿回路递归回溯算法***********\n");printf("********************************************\n");printf("请先创建一个n结点的连通图graph[n][n]\n");printf("请输入顶点n的值:");scanf_s("%d",&n);printf("图中一共有几条边？请输入以便我们创建图:");scanf_s("%d",&e);for(i=1;i<=n;i++)for(j=1;j<=n;j++)graph[i][j]=0;for(i=1;i<=e;i++){printf("\n创建第%d条边:\n",i);printf("构成此边的一个顶点号(1~%d):",n);scanf_s("%d",&a);printf("另一个顶点号(1~%d):",n);scanf_s("%d",&b);graph[a][b]=graph[b][a]=1;}x[1]=1;for(i=2;i<=n;i++)x[i]=0;printf("\n以下为所求hamiltonian回路的所有解\n");hamiltonian(2);}五．实验结果以及分析有哈密尔顿回路连通图：运行结果：无哈密尔顿回路连通图：六.总结通过本次课程设计，本人对算法设计与分析基础有了更深的认识，基本掌握了回溯法求解一般哈密尔顿回路的算法思路以及编程原理，提高了程序开发的能力，让能切实体会到算法在编程过程中的指导作用。
实验五_回溯法
算法分析与设计实验报告学号姓名班级上课地点教师上课时间实验五回溯法1. 实验目的1.1掌握回溯法的设计思想；1.2 掌握解空间树的构造方法，以及在求解过程中如何存储求解路径；1.3 学会利用回溯法解决实际问题。
2. 实验环境2.1 Eclipse2.2 Window XP3. 实验内容3.1 旅行商问题：给定一个n顶点网络（有向或无向），要求找出一个包含所有n个顶点的具有最小耗费的环路。
输入：顶点个数、邻接矩阵；输出：最小耗费、旅行的环路。
3.2 n后问题：nXn棋盘上放置n个皇后使得每个皇后互不受攻击，即任二皇后不能位于同行同列和同一斜线上。
输入：皇后的个数，输出：所有可能的方案以及总的方案数。
4. 教师批改意见成绩签字：日期：实验报告细表1旅行商问题1.1 算法设计思想回溯法就从开始结点（根结点）出发，以深度优先的方式搜索整个解空间。
这个开始结点就成为一个活结点，同时也成为当前的扩展结点。
在当前的扩展结点处，搜索向纵深方向移至一个新结点。
这个新结点就成为一个新的活结点，并成为当前扩展结点。
如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。
此时，应往回移动（回溯）至最近的一个活结点处，并使这个活结点成为当前的扩展结点。
回溯法即以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已没有活结点时为止。
1.2 程序源码package lvxingshang;import java.util.Scanner;public class Bttsp {static int n; // 图G的顶点数static int[] x; // 当前解static int[] bestx; // 当前最优解static float bestc; // 当前最优值static float cc; // 当前费用static float[][] a; // 图G的邻接矩阵public static void tsp() {// 置x为单位矩阵x = new int[n + 1];for (int i = 1; i <= n; i++) {x[i] = i;}bestc = (float) -1.0;bestx = new int[n + 1];cc = 0;System.out.println("最短路线为：");backtrack(2);for (int i = 1; i <= n; i++) {System.out.print(bestx[i] + " ");}System.out.println("1");}private static void backtrack(int i) {if (i == n) {if (a[x[n - 1]][x[n]] > 0&& a[x[n]][1] > 0&& (bestc < 0 || cc + a[x[n - 1]][x[n]]+ a[x[n]][1] < bestc)) {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++)// 是否可以进入x【j】子树？if (a[x[i - 1]][x[j]] > 0&& (bestc < 0 || cc + a[x[i - 1]][x[j]] < bestc)) { // 搜索子树int temp = x[i];cc += a[x[i - 1]][x[j]];x[i] = x[j];x[j] = temp;backtrack(i + 1);temp = x[i];x[i] = x[j];x[j] = temp;cc -= a[x[i - 1]][x[j]];}}}public static void main(String[] args) {Scanner s = new Scanner(System.in);System.out.println("请输入售货员要去的城市个数：");String line = s.nextLine();// 读入nn = Integer.parseInt(line);a = new float[n + 1][n + 1];System.out.println("请输入来往各个城市之间的花费 \n");for (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {a[i][j] = s.nextFloat();}}tsp();System.out.println("最短距离是：" + bestc);s.close();}}1.3 实验结论1.4 心得体会由于编程途中最优解一直输不出，尝试着各种方法，觉得很累。
回溯算法实验报告
回溯算法实验报告实验目的：回溯算法是一种递归算法，通常用于解决有限集合的组合问题。
本实验旨在通过实现回溯算法来解决一个具体的问题，并对算法的性能进行评估。
实验内容：本实验将以八皇后问题为例，展示回溯算法的应用。
八皇后问题是一个经典的问题，要求在一个8x8的棋盘上放置8个皇后，使得任意两个皇后不能在同一行、同一列或同一对角线上。
算法步骤：1. 创建一个二维数组，表示棋盘。
初始化所有元素为0，表示棋盘上无皇后。
2. 逐行进行操作，尝试在每一列放置皇后。
在每一列，从上到下逐个位置进行尝试，找到一个合适的位置放置皇后。
3. 如果找到合适的位置，则将该位置标记为1，并向下一行进行递归操作。
4. 如果当前位置无法放置皇后，则回溯到上一行，尝试放置皇后的下一个位置。
5. 当所有皇后都放置好后，得到一个解。
将该解加入结果集中。
6. 继续回溯，尝试寻找下一个解。
7. 当所有解都找到后，算法终止。
实验结果：在本实验中，我们实现了八皇后问题的回溯算法，并进行了性能测试。
根据实验结果可以看出，回溯算法在解决八皇后问题上表现出较好的性能。
实验中，我们使用的是普通的回溯算法，没有进行优化。
对于八皇后问题来说，回溯算法可以找到所有解，但是随着问题规模的增加，算法的执行时间也会大大增加。
回溯算法是一种非常灵活的算法，可以用于解决各种组合问题。
对于规模较大的问题，回溯算法的时间复杂度很高，需要考虑优化算法以提高性能。
在实际应用中，可以结合其他算法，如剪枝等技巧，来改进回溯算法的性能。
回溯算法是一种非常有价值的算法，值得进一步研究和应用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验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的参数。
cw记录当前结点相应的装载重量，bestw记录当前最大装载重量。
在算法backtrack中，当i>n时，算法搜索至叶结点，其相应的装载重量cw。
如果cw>bestw,则表示当前解优于当前最优解,此时应更新bestw。
当i<=n时，当前扩展结点Z是子集树的内部结点。
该结点有x[i]=1和x[i]=0两个儿子结点。
其左儿子结点表示x[i]=1的情形，仅当cw+w[i]<=c时进入左子树，对左子树递归搜索。
其右儿子结点表示x[i]=0的情形。
由于可行结点的右儿子结点总是可行的，故进入右子树时不需检查可行性。
算法backtrack动态地生成问题的解空间树。
在每个结点处算法花费O(1)时间。
子集树中结点个数为O(2的n次方)，故backtrack所需的计算时间为O(2的n 次方)。
另外backtrack还需要额外的O(n)递归栈空间。
2、n后问题用n元祖x[1:n]表示n后问题的解。
其中x[i]表示皇后i放在棋盘的第i行的第x[i]列。
由于不允许将2个皇后放在同一列，所以解向量中的x[i]互不相同。
2个皇后不能放在同一斜线上是问题的隐约束。
对于一般的n后问题，这一隐约束条件可以化成显约束的形式。
将n×n格棋盘看作二维方阵，其行号从上到下，列号从左到右依次编号为1,2，…，n。
从棋盘左上角到右下角的主对角线及其平行线(即斜率为-1的各斜线)上，2个下标值的差(行号-列号)值相等。
同理，斜率为+1的每一条斜线上，2个下标值的和(行号+列号)值相等。
因此，若2个皇后放置的位置分别是(i，j)和(k，l)，且i-j=k-l或i+j=k+l，则说明这2个皇后处于同一斜线上。
以上2个方程分别等价于i-k=j-l和i-k=l-j。
由此可知，只要|i-k|=|j-l|成立，就表明2个皇后位于同一条斜线上。
问题的隐约束化成了显约束。
用回溯法解n后问题时，用完全n叉树表示解空间。
可行性约束place剪去不满足行、列和斜线约束的子树。
解n后问题的回溯法中，递归方法backtrack(1)实现对整个解空间的回溯搜索。
Backtrack(i)搜索解空间中第i层子树。
类Queen的数据成员记录解空间中节点信息，以减少传给backtrack的参数。
Sum记录当前已找到的可行方案数。
在算法backtrack中，当i>n时，算法搜索至叶节点，得到一个新的n皇后互不攻击方案，当前已找到的可行方案数sum曾1.当i<=n时，当前扩展节点Z是解空间中的内部结点。
该结点有x[i]=1,2,…，n，共n个儿子结点。
对当前扩展结点Z的每一个儿子结点，由place检查其可行性，并以深度优先的方式递归地对可行子树搜索，或剪去不可行子树。
3、图的m着色问题给定图G=(V,E)和m种颜色，用图的邻接矩阵a表示无向连接图G=(V,E)。
若(i,j)属于图G=(V,E)的边集E，则a[i][j]=0。
整数1,2，…，m用来表示m种不同颜色。
顶点i所着颜色用x[i]表示。
数组x[1:n]是问题的解向量。
问题的解空间可表示为一棵高度为n+1的完全m叉树。
解空间树的第i(1<=i<=n)层中每一结点都有m个儿子，每个儿子相应于x[i]的m个可能的着色之一。
第n+1层结点均为叶节点。
在解图的m着色问题的回溯法中，backtrack(i)搜索解空间中第i层子树。
类Coloring的数据成员记录解空间中结点信息，以减少传给backtrack的参数。
Sum记录当前找到的m可着色方案数。
在算法backtrack中，当i>n时，算法搜索至叶结点，得到新的m着色方案，当前找到的m可着色方案数sum增1。
当i<=n时，当前扩展结点Z是解空间中的内部结点。
该结点有x[i]=1,2,…，m 共m个儿子结点。
对当前扩展结点Z的每一个儿子结点，由方案ok检查其可行性，并以深度优先的方式递归地对可行子树搜索，或剪去不可行子树。
五、实验程序功能模块1、装载问题import ;public class MainLoading {public static void main(String[] args) throws IOException { Loading loading = new Loading();int n = 4;"集装箱个数: " + n);int[] x = new int[n + 1];String[] b = new String[n];String a = "30 50 20 70";"集装箱重量: " + a);int[] w = new int[n + 1];w[1] = 30;w[2] = 50;w[3] = 20;w[4] = 70;int c1 = 130;int c2 = 70;"轮船载重量: " + c1 + "," + c2);int result = loading.maxloading(w, c1, x);int max, temp;for (int i = 1; i < 3; i++) {for (int j = 2; j < 3; j++) {if (w[i] > w[j]) {temp = w[i];w[i] = w[j];w[j] = temp;}}}if ((w[3] > c1) && (w[3] > c2)) {"都不可装");}else {"轮船1装载的集装箱：");for (int u = 1; u < n + 1; u++)if (loading.bestx[u] == 1)+ " ");if (loading.r > (result + c2))"轮船1可装：" + result + " " + "轮船2装不完.");else {"轮船2装载的集装箱：");for (int u = 1; u < n + 1; u++)if (loading.bestx[u] == 0)+ " ");"最优装载--轮船1:" + result + " " + "轮船2:"+ (loading.r - result));}}}}public class Loading {static int n;static int[] w;static int c1, c2; // 第一、二艘轮船的载重量static int cw;static int bestw;static int r;static int[] x;static int[] bestx;public static int maxloading(int[] ww, int cc, int[] xx) { n = ww.length - 1;w = ww;c1 = cc;bestw = 0;cw = 0;x = new int[n + 1];bestx = xx;r = 0;for (int i = 1; i <= n; i++)r += w[i];backtrack(1);return bestw;}private static void backtrack(int i) {if (i > n) {if (cw > bestw) {for (int j = 1; j <= n; j++)bestx[j] = x[j];bestw = cw;}return;}r -= w[i];if (cw + w[i]<=c1){x[i] = 1;cw += w[i];backtrack(i + 1);cw -= w[i];}if (cw + r > bestw) {x[i] = 0;backtrack(i + 1);}r += w[i];}}2、n后问题import ;public class MainNQueen {public static void main(String[] args) {nQueen nqueen = new nQueen();int nn; // 输入n值int sum; // 可行方案个数try {nn = 4; // 将输入值转换为int保存if (nn <= 0) {throw new IOException("不能输入负数");}"方格数是：" + nn);sum = nqueen.nQueen(nn); // 调用nqueen方法"可行方案个数为：" + sum); // 输出sum} catch (IOException e) {;} catch (NumberFormatException e) {"请输入数字。