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. }
10. 用回溯法搜索排列树的算法框架：

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

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

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

八皇后问题是一个古老而著名的问题，是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上.
问题分析:
第一步 定义问题的解空间
这个问题解空间就是8个皇后在棋盘中的位置.
第二步 定义解空间的结构
可以使用8*8的数组，但由于任意两个皇后都不能在同行，我们可以用数组下标表示
行，数组的值来表示皇后放的列，故可以简化为一个以维数组x[9]。
第三步 以深度优先的方式搜索解空间，并在搜索过程使用剪枝函数来剪枝
根据条件:x[i] == x[k]判断处于同一列
abs(k-i) == abs(x[k]-x[i]判断是否处于同一斜线
我们很容易写出剪枝函数：

Cpp代码

1. bool canPlace(int k){
2. for(int i = 1; i < k; i++){

• //判断处于同一列或同一斜线
• if(x[i] == x[k] || abs(k-i) == abs(x[k]-x[i]))              return false;
• }
• return true;
• }

Cpp代码

1. void queen(int i){
2. if(i > 8){
3. print();
4. return;
5. }
6. for(int j = 1; j <= 8; j++){
7. x[i] = j;//记录所放的列
8. if(canPlace(i)) queen(i+1);
9. }
10. }

Cpp代码

1. #include<iostream>
2. #include<cmath>
3. using namespace std;
4. int x[9];
5. void print(){
6. for(int i = 1; i <= 8; i++)
7. cout << x[i] << " ";
8. cout << endl;
9. }
10. bool canPlace(int k){
11. for(int i = 1; i < k; i++){
12. //判断处于同一列或同一斜线
13. if(x[i] == x[k] || abs(k-i) == abs(x[k]-x[i]))
14. return false;
15. }
16. return true;
17. }
18. void queen(int i){
19. if(i > 8){
20. print();
21. return;
22. }
23. for(int j = 1; j <= 8; j++){
24. x[i] = j;
25. if(canPlace(i)) queen(i+1);
26. }
27. }
28. int main(){
29. queen(1);
30. return 0;
31. }

0-1背包问题