回溯法之一---算法框架及基础

回溯法之一---算法框架及基础

回溯法其实也是一种搜索算法，它可以方便的搜索解空间。
回溯法解题通常可以从以下三步入手：
1、针对问题，定义解空间
2、确定易于搜索的解空间结构
3、以深度优先的方式搜索解空间，并在搜索的过程中进行剪枝
回溯法通常在解空间树上进行搜索，而解空间树通常有子集树和排列树。
针对这两个问题，算法的框架基本如下：
用回溯法搜索子集合树的一般框架：

[cpp] view plaincopy

    void backtrack(int t){  
      if(t > n) output(x);  
      else{  
        for(int i = f(n,t); i <= g(n,t);i++){  
              x[t] = h(i);  
              if(constraint(t) && bound(t)) backtrack(t+1);  
         }  
      }  
    }  


用回溯法搜索排列树的算法框架：

[cpp] view plaincopy

    void backtrack(int t){  
      if(t > n) output(x);  
      else{  
        for(int i = f(n,t); i <= g(n,t);i++){  
              swap(x[t],x[i]);  
              if(constraint(t) && bound(t)) backtrack(t+1);  
              swap(x[t],x[i]);   
        }  
      }  
    }  


其中f(n,t),g(n,t)表示当前扩展结点处未搜索过的子树的起始标号和终止标号,
h(i)表示当前扩展节点处，x[t]第i个可选值。constraint(t)和bound(t)是当前
扩展结点处的约束函数和限界函数。constraint(t)返回true时，在当前扩展结点
x[1:t]取值满足约束条件，否则不满足约束条件，可减去相应的子树。bound(t)返
回的值为true时，在当前扩展结点x[1:x]处取值未使目标函数越界，还需要由backtrack(t+1)
对其相应的子树进一步搜索。
用回溯法其实质上是提供了搜索解空间的方法，当我们能够搜遍解空间时，
显然我们就能够找到最优的或者满足条件的解。这便是可行性的问题， 而效率可以
通过剪枝函数来降低。但事实上一旦解空间的结构确定了，很大程度上时间复杂度
也就确定了，所以选择易于搜索的解空间很重要。
下面我们看看两个最简单的回溯问题，他们也代表了两种搜索类型的问题：子集合问题和
排列问题。
第一个问题：
求集合s的所有子集(不包括空集),我们可以按照第一个框架来写代码：

[cpp] view plaincopy

    #include<iostream>  
    using namespace std;  
      
    int s[3] = {1,3,6};  
    int x[3];  
    int  N = 3;  
    void print(){  
       for(int j = 0; j < N; j++)  
        if(x[j] == 1)  
           cout << s[j] << " ";  
       cout << endl;  
    }  
      
    void subset(int i){  
        if(i >= N){  
            print();  
            return;  
        }  
      
        x[i] = 1;//搜索右子树  
        subset(i+1);  
        x[i] = 0;//搜索左子树  
        subset(i+1);  
    }  
      
    int main(){  
      subset(0);  
      return 0;  
    }  



下面我们看第二个问题：排列的问题，求一个集合元素的全排列。
我们可以按照第二个框架写出代码：

[cpp] view plaincopy

    #include<iostream>  
    using namespace std;  
      
    int a[4] = {1,2,3,4};  
    const int N = 4;  
      
    void print(){  
        for(int i = 0; i < N; i++)  
               cout << a[i] << " ";  
        cout << endl;  
    }  
      
    void swap(int *a,int i,int j){  
      int temp;  
      temp = a[i];  
      a[i] = a[j];  
      a[j] = temp;  
    }  
      
    void backtrack(int i){  
        if(i >= N){  
            print();  
        }  
        for(int j = i; j < N; j++){  
            swap(a,i,j);  
            backtrack(i+1);  
            swap(a,i,j);  
        }  
    }  
      
    int main(){  
      backtrack(0);  
      return 0;  
    }  


这两个问题很有代表性，事实上有许多问题都是从这两个问题演变而来的。第一个问题，它穷举了所有问题的子集，这是所有第一种类型的基础，第二个问题,它给出了穷举所有排列的方法，这是所有的第二种类型的问题的基础。理解这两个问题,是回溯算法的基础.
下面看看一个较简单的问题：
整数集合s和一个整数sum，求集合s的所有子集su,使得su的元素之和为sum。
这个问题很显然是个子集合问题，我们很容易就可以把第一段代码修改成这个问题的代码：

[cpp] view plaincopy

    int sum = 10;  
    int r = 0;  
    int s[5] = {1,3,6,4,2};  
    int x[5];  
    int  N = 5;  
      
    void print(){  
       for(int j = 0; j < N; j++)  
        if(x[j] == 1)  
           cout << s[j] << " ";  
       cout << endl;  
    }  
    void sumSet(int i){  
        if(i >= N){  
            if(sum == r) print();  
            return;  
        }  
        if(r < sum){//搜索右子树  
          r += s[i];  
          x[i] = 1;  
          sumSet(i+1);  
          r -= s[i];   
        }  
        x[i] = 0;//搜索左子树  
        sumSet(i+1);  
    }  
      
    int main(){  
      sumSet(0);  
      return 0;  
    }