回溯法（2）

一、  回溯的基本思想是：     从一个给定的起始位置，我们希望到达一个目的位置。 我们重复地进行选择（可能是猜测）下一个位置应当是什么。如果一个给定的选择是有效的， 即新的位置可能位于通向目的位置的途径中，则前进到这个新的位置，然后继续。 如果一个给定的选择通向了死胡同 ，则回到前面的位置，进行其他的选择。 回溯就是通过一系列位置选择到达目的位置，并且在不能到达目的位置时反向退回的策略。  通俗的讲法：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 算法书上可能这样说：回溯法是在包含问题的所有解的解空间树(或森林)中，按照深度优先的策略，从根结点出发搜索解空间树。 算法搜索至解空间树的任一结点时，总是先判断该结点是否满足问题的约束条件。如果满足进入该子树，继续 按照深度优先的策略进行搜索。否则，不去搜索以该结点为根的子树，而是逐层向其祖先结点回溯。

    回溯法在用来求解问题的所有解时，要回溯到根，且根结点的所有可行的子树都已被搜索遍才结束。而回溯法在用来求解问题的任一解时，只要搜索到问题的一个解就可以结束。适用于解决一些最优化问题。 

二. 算法设计过程

(1) 确定问题的解空间    
应用回溯法解决问题时，首先应明确定义问题的解空间。问题的解空间应至少包含问题的一个最优解。

(2) 确定结点的扩展规则 
约束条件。

(3) 搜索解空间 
   回溯算法从开始结点(根结点)出发，以深度优先的方式搜索整个解空间。这个开始结点就成为一个活结点，同时也成为当前的扩展结点。在当前的扩展结点处，搜索向纵深方向移至一个新结点。这个新结点就成为一个新的活结点，并成为当前扩展结点。如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应该往回移动(回溯)至最近的一个活结点处，并使这个活结点成为当前的扩展结点。回溯法即以这种工作方式递归地在解空间中 
搜索，直至找到所要求的解或解空间中已没有活结点时为止。

三. 算法框架 
(1) 问题框架

设问题的解是一个n维向量(a1,a2,...,an),约束条件是ai(i=1,2,...,n)之间满足某种条件，记为f(ai)。

(2) 非递归回溯框架 
int a[n], i; 
i=1; 
while(i>0(有路可走) and [未达到目标]){ //还未回溯到头 
  if(i>n){ //搜索到叶结点 
    搜索到一个解，输出； 
  }else{ 
   a[i]第一个可能的值； 
   while(a[i]不满足约束条件且在搜索空间内) 
    a[i]下一可能的值； 
    if(a[i]在搜索空间内){ 
     标识占用的资源； 
      i = i+1; //扩展下一个结点 
   }else{ 
     清理所占的状态空间； 
     i = i-1; //回溯 
   } 
 } 
}

(3)递归算法框架 
int a[n]; 
try(int i){ 
   if(i>n){ 
      输出结果； 
  }else{ 
     for(j=下界; j<=上界; j++){//枚举i所有可能的路径 
       if(f(j)){ //满足限界函数和约束条件 
          a[i] = j; 
          ... //其他操作 
         try(i+1); 
          a[i] = 0; //回溯前的清理工作(如a[i]置空) 
       } 
     } 
   } 
} 

四、例
1. 问题描述： 输出自然数1到n的所有不重复的排列，即n的全排列。

2. 问题分析： 
(1) 解空间： n的全排列是一组n元一维向量(x1, x2, x3, ... , xn),搜索空间是：1<=xi<=n i=1,2,3,...,n 

(2) 约束条件： xi互不相同。技巧：采用"数组记录状态信息", 设置n个元素的一维数组d，其中的n个元素用来记录数据 
1~n的使用情况，已使用置1，未使用置0

3. Java代码：

/**  
 * 回溯法  
 *   
 * @since jdk1.6  
 * @author 毛正吉  
 * @version 1.0  
 * @date 2010.05.25  
 *   
 */  
public class NAllArrangement {   
    private int count = 0; // 解数量   
    private int n; // 输入数据n   
    private int[] a; // 解向量   
    private int[] d; // 解状态   
  
    /**  
     * @param args  
     */  
    public static void main(String[] args) {   
        //测试例子   
        NAllArrangement na = new NAllArrangement(5, 100);   
        na.tryArrangement(1);   
  
    }   
  
    public NAllArrangement(int _n, int maxNSize) {   
        n = _n;   
        a = new int[maxNSize];   
        d = new int[maxNSize];   
    }   
  
    /**  
     * 处理方法  
     *   
     * @param k  
     */  
    public void tryArrangement(int k) {   
        for (int j = 1; j <= n; j++) { // 搜索解空间   
            if (d[j] == 0) {   
                a[k] = j;   
                d[j] = 1;   
            } else { // 表明j已用过   
                continue;   
            }   
  
            if (k < n) { // 没搜索到底   
                tryArrangement(k + 1);   
            } else {   
                count++;   
                output(); // 输出解向量   
            }   
            d[a[k]] = 0; // 回溯   
        }   
    }   
  
    /**  
     * 输出解向量  
     */  
    private void output() {   
        System.out.println("count = " + count);   
        for (int j = 1; j <= n; j++) {   
            System.out.print(a[j] + " ");   
        }   
        System.out.println("");   
    }   
  
}  

 

运行结果：
C:\java>java NAllArrangement
count = 1
1 2 3 4 5
count = 2
1 2 3 5 4
count = 3
1 2 4 3 5
count = 4
1 2 4 5 3
count = 5
1 2 5 3 4
count = 6
1 2 5 4 3
count = 7
1 3 2 4 5
count = 8
1 3 2 5 4
count = 9
1 3 4 2 5
。。。。。。。。

 

【问题】 组合问题 
问题描述：找出从自然数1，2，…，n中任取r个数的所有组合。 
采用回溯法找问题的解，将找到的组合以从小到大顺序存于a[0]，a[1]，…，a[r-1]中，组合的元素满足以下性质： 
（1） a[i+1]>a[i]，后一个数字比前一个大； 
（2） a[i]-i<=n-r+1。

按回溯法的思想，找解过程可以叙述如下： 
   首先放弃组合数个数为r的条件，候选组合从只有一个数字1开始。因该候选解满足除问题规模之外的全部条件，扩大其规模，并使其满足上述条件（1），候选组合改为1，2。继续这一过程，得到候选组合1，2，3。该候选解满足包括问题规模在内的全部条件，因而是一个解。在该解的基础上，选下一个候选解，因a[2]上的3调整为4，以及以后调整为5都满足问题的全部要求，得到解1，2，4和1，2，5。由于对5不能再作调整，就要从a[2]回溯到a[1]，这时，a[1]=2，可以调整为3，并向前试探，得到解1，3，4。重复上述向前试探和向后回溯，直至要从a[0]再回溯时，说明已经找完问题的全部解。按上述思想写成程序如下：

public class TestComb{
   public static void main(String args[]){
      comb(6,3);
   }
   public static void comb(int m,int r){
      int i=0,j;
      int a[]=new int[100];
      a[i]=1;
      do { 
      if (a[i]-i<=m-r+1)/*还能向前试探*/
      {   if(i==r-1)/*已经找到一个可行的组合解*/
         {   for (j=0;j< r;j++)
               System.out.printf("%4d",a[j]);
            System.out.println(); 
         
         a[i]++;/*调整*/
         continue;
         }
           i++;/*扩展,向前试探*/
          a[i]=a[i-1]+1;
      }
        
      else/*不能试探,理应回溯*/
      {   if (i==0) /找到所有可行的解,结束*/
            return; 
         a[--i]++; /*调整,向后回溯*/
      }
   }while(true);
 }
}

运行：
C:\java>java TestComb
1 2 3
1 2 4
1 2 5
1 2 6
1 3 4
1 3 5
1 3 6
1 4 5
1 4 6
1 5 6
2 3 4
2 3 5
2 3 6
2 4 5
2 4 6
2 5 6
3 4 5
3 4 6
3 5 6
4 5 6