实验4 回溯法

实验4. 回溯法一、 实验目的1. 理解回溯法的基本思想。

2. 运用回溯法解决实际问题。

二、 实验环境与地点1. 实验环境：Windows7,Eclipse2. 实验地点：网络工程实验室三、 实验内容与步骤编写程序完成下列题目，上机调试并运行成功。

1. 有n 个集装箱要装上2艘载重分别为c1和c2 的轮船，其中集装箱 i 的重量为 w i ，且装载问题要求确定是否有一个合理的装载方案可将这些集装箱装上这 2 艘轮船。

如果有，找出一种装载方案。

思路：可以证明，如果一个给定装载问题有解，则采用下面的策略可得到最优装载方案。

(1)首先将第一艘轮船尽可能装满；(2)将剩余的集装箱装上第二艘轮船。

将第一艘轮船尽可能装满等价于选取全体集装箱的一个子集，使该子集中集装箱重量之和最接近c1。

由此可知，装载问题等价于以下特殊的0-1背包问题。

输入： w = [10,40,40]c1 = c2 = 50;输出：1,2装第一艘船，其余第2艘船。

令第一艘船的装入量为W1,用回溯算法求使得c1−W1达到最小的装载方案；若满足w1+w2+...+wn−W1≤ c2，则回答“Yes ”,否则回答“No ”步骤：(1) 解空间：子集树可行性约束函数(选择当前元素)：211c c wn i i +≤∑=界限函数(不选择当前元素)：当前载重量cw+剩余集装箱的重量r <=当前最优载重量bestw(2) 算法：public class Loading {// 类数据成员static int n ;// 集装箱数static int [] w ; // 集装箱重量数组static int c ;// 第一艘轮船的载重量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 ;c = cc ;cw = 0;bestw = 0;x = new int [n + 1];bestx = xx ;// 初始化rfor (int i = 1; i <= n ; i ++)r += w [i ];// 计算最优载重量backtrack (1);return bestw ;}// 回溯算法private static void backtrack(int i ) {// 搜索第i 层结点if (i > n ) {// 到达叶结点if (cw > bestw ) {for (int j = 1; j <= n ; j ++)bestx [j ] = x [j ];bestw = cw ;}return ;}11c x w n i i i≤∑=// 搜索子树r -= w [i ];if (cw + w [i ] <= c ) {// 搜索左子树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 ];} public static void main(String[] args ) {// TODO Auto-generated method stub//自己编写代码完成main 方法……}}(3) 测试：输入： W = < 90,80,40,30,20,12,10 >c1=152, c2=130输出：1,3,6,7装第一艘船，其余第2艘船。

2. 批处理作业调度：给定n 个作业的集合{J 1,J 2,…,J n }。

每个作业必须由两台机器处理，且先由机器1处理，再由机器2处理。

作业J i 需要机器j 的处理时间为t ji 。

F ji 是作业i 在机器j 上完成处理的时间。

所有作业在机器2上完成时间和: 批处理作业调度问题要求对于给定的 n 个作业，制定最佳作业调度方案，使其完成时间总和达到最短。

思路：由于每个作业都要处理，只是每个作业在机器上的处理顺序不同，因此，流水作业调度问题的一个候选解是n 个作业的一个排列。

解空间能够组织成一棵排列树。

解空间的大小为n!。

如果在搜索过程中不考虑任何剪支函数，效率低。

但是，该问题里没有显式的约束函数，因此，我们可考虑界限函数。

n i i f F ==∑21这3个作业的6种可能的调度方案是1,2,3；1,3,2；2,1,3；2,3,1；3,1,2；3,2,1；对应的完成时间和分别是19，18，20，21，19，19。

最佳调度方案是1,3,2。

对于当前要加工的作业x[j]，在机器1上处理后，记录其结束时间f1,机器2能够接着处理作业x[j]，取决于当前机器2是否空闲：如果机器1上处理作业x[j]后，前一个作业在机器2上还没有处理完，作业x[j]只能等待机器2。

同样，如果机器2早就结束了对前一个作业的处理，而机器1仍然还在处理当前作业x[j]，因此，机器2必须等待机器1完成处理作业x[j]后，才能处理x[j]。

因此，我们必须比较机器2完成前一个作业的完成时间f2[i-1]与f1的大小，然后才能决定机器2从什么时候开始处理x[j]。

步骤：(1)解空间树——排列树(2)算法import java.util.Arrays;public class FlowShop {static int[][] m= {{0,0,0,},{0,2,1,},{0,3,1,},{0,2,3,}}; // 各作业所需的处理时间static int[] x=new int[m.length];// 当前作业调度static int[] bestx=new int[x.length];// 当前最优作业调度static int[] f2=new int[x.length]; // 机器2完成处理时间static int n=x.length-1, // 作业数f1=0, // 机器1完成处理时间f=0, // 完成时间和bestf=99999; // 当前最优值private static void backtrack(int i) {if (i > n) {//得到一个当前最优解for (int j = 1; j <= n; j++)bestx[j] = x[j];bestf = f;//bestf的初值为一最大值99999} elsefor (int j = i; j <= n; j++) {f1 += m[x[j]][1];//第i个被调度的作业j在机器1的完成处理的时间//第i个被调度作业j在机器2上完成处理的时间f2[i] = ((f2[i - 1] > f1) ? f2[i - 1] : f1) + m[x[j]][2];//前i个被调度作业在机器2上完成处理的时间和f += f2[i];if (f < bestf) {//限界条件MyMath.swap(x, i, j);//将作业j换到最前作为排列前缀backtrack(i + 1);MyMath.swap(x, i, j);//回溯后，将作业j换回原来位置}f1 -= m[x[j]][1];//回溯到第i-1层，恢复前i-1个作业在机器1上的完成处理时间f -= f2[i];//回溯到第i-1层，恢复前i-1个作业在机器2上的完成处理时间和}}public static void main(String[] args) {// TODO Auto-generated method stub//自己编写代码完成main方法……}}四、实验总结与分析此处要包含前面算法的时间复杂度分析。

参考代码：(1)Loading：import java.util.Arrays;public class Loading {// 类数据成员static int n;// 集装箱数static int[] w; // 集装箱重量数组static int c;// 第一艘轮船的载重量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;c = cc;cw = 0;bestw = 0;x = new int[n + 1];bestx = xx;// 初始化rfor (int i = 1; i <= n; i++)r += w[i];// 计算最优载重量backtrack(1);return bestw;}// 回溯算法private static void backtrack(int i) {// 搜索第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] <= c) {// 搜索左子树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];}public static void main(String[] args) {// TODO Auto-generated method stubint[] ww= {0,10,40,40, };//0,90,80,40,30,20,12,10 int c1=50;int c2=50;int cc2=0;int[] xx= new int[ww.length];maxLoading(ww,c1,xx);for (int i = 1; i < xx.length; i++) {if (xx[i]==0) {cc2+=ww[i];}}if (cc2<=c2) {System.out.println("yes");System.out.println(bestw);System.out.println(Arrays.toString(bestx));}else {System.out.println("no");}}}(2)FlowShopimport java.util.Arrays;public class FlowShop {static int[][] m= {{0,0,0,},{0,2,1,},{0,3,1,},{0,2,3,}}; // 各作业所需的处理时间static int[] x=new int[m.length];// 当前作业调度static int[] bestx=new int[x.length];// 当前最优作业调度static int[] f2=new int[x.length]; // 机器2完成处理时间static int n=x.length-1, // 作业数f1=0, // 机器1完成处理时间f=0, // 完成时间和bestf=99999; // 当前最优值private static void backtrack(int i) {if (i > n) {//得到一个当前最优解for (int j = 1; j <= n; j++)bestx[j] = x[j];bestf = f;//bestf的初值为一最大值99999} elsefor (int j = i; j <= n; j++) {f1 += m[x[j]][1];//第i个被调度的作业j在机器1的完成处理的时间//第i个被调度作业j在机器2上完成处理的时间f2[i] = ((f2[i - 1] > f1) ? f2[i - 1] : f1) + m[x[j]][2];//前i个被调度作业在机器2上完成处理的时间和f += f2[i];if (f < bestf) {//限界条件MyMath.swap(x, i, j);//将作业j换到最前作为排列前缀backtrack(i + 1);MyMath.swap(x, i, j);//回溯后，将作业j换回原来位置}f1 -= m[x[j]][1];//回溯到第i-1层，恢复前i-1个作业在机器1上的完成处理时间f -= f2[i];//回溯到第i-1层，恢复前i-1个作业在机器2上的完成处理时间和}}public static void main(String[] args) {// TODO Auto-generated method stubfor (int i = 1; i < x.length; i++) {x[i]=i;}backtrack(1);System.out.println(bestf);System.out.println(Arrays.toString(bestx));}}public class MyMath {public static void swap(int[] data, int a, int b) {int temp;temp = data[a];data[a] = data[b];data[b] = temp;}}。