回溯算法的框架和基础

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

Cpp代码

1. void backtrack(int t){   
2.   if(t > n) output(x);   
3.   else{   
4.     for(int i = f(n,t); i <= g(n,t);i++){   
5.           x[t] = h(i);   
6.           if(constraint(t) && bound(t)) backtrack(t+1);   
7.      }   
8.   }   
9. }  

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代码

1. void backtrack(int t){   
2.   if(t > n) output(x);   
3.   else{   
4.     for(int i = f(n,t); i <= g(n,t);i++){   
5.           swap(x[t],x[i]);   
6.           if(constraint(t) && bound(t)) backtrack(t+1);   
7.           swap(x[t],x[i]);    
8.     }   
9.   }   
10. }  

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代码

1. #include<iostream>   
2. using namespace std;   
3.   
4. int s[3] = {1,3,6};   
5. int x[3];   
6. int  N = 3;   
7. void print(){   
8.    for(int j = 0; j < N; j++)   
9.     if(x[j] == 1)   
10.        cout << s[j] << " ";   
11.    cout << endl;   
12. }   
13.   
14. void subset(int i){   
15.     if(i >= N){   
16.         print();   
17.         return;   
18.     }   
19.   
20.     x[i] = 1;//搜索右子树   
21.     subset(i+1);   
22.     x[i] = 0;//搜索左子树   
23.     subset(i+1);   
24. }   
25.   
26. int main(){   
27.   subset(0);   
28.   return 0;   
29. }  

#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代码

1. #include<iostream>   
2. using namespace std;   
3.   
4. int a[4] = {1,2,3,4};   
5. const int N = 4;   
6.   
7. void print(){   
8.     for(int i = 0; i < N; i++)   
9.            cout << a[i] << " ";   
10.     cout << endl;   
11. }   
12.   
13. void swap(int *a,int i,int j){   
14.   int temp;   
15.   temp = a[i];   
16.   a[i] = a[j];   
17.   a[j] = temp;   
18. }   
19.   
20. void backtrack(int i){   
21.     if(i >= N){   
22.         print();   
23.     }   
24.     for(int j = i; j < N; j++){   
25.         swap(a,i,j);   
26.         backtrack(i+1);   
27.         swap(a,i,j);   
28.     }   
29. }   
30.   
31. int main(){   
32.   backtrack(0);   
33.   return 0;   
34. }  

#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代码

1. int sum = 10;   
2. int r = 0;   
3. int s[5] = {1,3,6,4,2};   
4. int x[5];   
5. int  N = 5;   
6.   
7. void print(){   
8.    for(int j = 0; j < N; j++)   
9.     if(x[j] == 1)   
10.        cout << s[j] << " ";   
11.    cout << endl;   
12. }   
13. void sumSet(int i){   
14.     if(i >= N){   
15.         if(sum == r) print();   
16.         return;   
17.     }   
18.     if(r < sum){//搜索右子树   
19.       r += s[i];   
20.       x[i] = 1;   
21.       sumSet(i+1);   
22.       r -= s[i];    
23.     }   
24.     x[i] = 0;//搜索左子树   
25.     sumSet(i+1);   
26. }   
27.   
28. int main(){   
29.   sumSet(0);   
30.   return 0;   
31. }