回溯法－算法框架及基础

2023年6月17日 264次阅读 来源: 回溯法

回溯法其实也是一种搜索算法，它可以方便的搜索解空间。

回溯法解题通常可以从以下三步入手：

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

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. }  

其中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.   
  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. }  

下面我们看第二个问题：排列的问题，求一个集合元素的全排列。

我们可以按照第二个框架写出代码：

Cpp代码

  1. #include   
  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. }  

这两个问题很有代表性，事实上有许多问题都是从这两个问题演变而来的。第一个问题，它穷举了所有问题的子集，这是所有第一种类型的基础，第二个问题,它给出了穷举所有排列的方法，这是所有的第二种类型的问题的基础。理解这两个问题,是回溯算法的基础.

下面看看一个较简单的问题：

整数集合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. }  


                                                        八皇后问题

八皇后问题是一个古老而著名的问题，是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯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
;   
}  

然后我们按照回溯框架一，很容易写出8皇后的回溯代码：

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.   
  5. int x[9];   
  6. void print(){   
  7.     for(int i = 1; i <= 8; i++)   
  8.            cout << x[i] << ” “;   
  9.     cout << endl;   
  10. }   
  11.   
  12. bool canPlace(int k){   
  13.     for(int i = 1; i < k; i++){   
  14.             //判断处于同一列或同一斜线   
  15.        if(x[i] == x[k] || abs(k-i) == abs(x[k]-x[i]))    
  16.            return false;   
  17.     }   
  18.     return true;   
  19. }   
  20.   
  21. void queen(int i){   
  22.     if(i > 8){   
  23.         print();   
  24.         return;   
  25.     }   
  26.     for(int j = 1; j <= 8; j++){   
  27.       x[i] = j;   
  28.       if(canPlace(i)) queen(i+1);   
  29.     }   
  30. }   
  31.   
  32. int main(){   
  33.   queen(1);   
  34.   return 0;   
  35. }  


                                      0-1背包问题

0-1背包问题:给定n种物品和一背包.物品i的重量是wi, 其价值为ui,背包的容量为C.

问如何选择装入背包的物品,使得装入背包中物品的总价值最大?

分析:

0-1背包是子集合选取问题,一般情况下0-1背包是个NP问题.

第一步　确定解空间：装入哪几种物品

第二步　确定易于搜索的解空间结构：

可以用数组p,w分别表示各个物品价值和重量。

用数组x记录，是否选种物品

第三步　以深度优先的方式搜索解空间，并在搜索的过程中剪枝

我们同样可以使用子集合问题的框架来写我们的代码，和前面子集和数问题相差无几。

Cpp代码

  1. #include<iostream>   
  2. #include<algorithm>   


using
 
namespace
 std;   
  

class
 Knapsack{   

public
:   
    Knapsack(
double
 *pp,
double
 *ww,
int
 nn,
double
 cc){   
       p = pp;   
       w = ww;   
       n = nn;   
       c = cc;   
       cw = 0;   
       cp = 0;   
       bestp = 0;   
       x = 
new
 
int
[n];   
       cx = 
new
 
int
[n];   
    }   
  
    
void
 knapsack(){   
       backtrack(0);   
     }   
  
    
void
 backtrack(
int
 i){
//回溯法
  
        
if
(i > n){   
            
if
(cp > bestp){   
               bestp = cp;   
               
for
(
int
 i = 0; i < n; i++)   
             x[i] = cx[i];   
            }   
            
return
;   
        }   
  
        
if
(cw + w[i] <= c){
//搜索右子树
  
          cw += w[i];   
          cp += p[i];   
          cx[i] = 1;   
          backtrack(i+1);   
          cw -= w[i];   
          cp -= p[i];   
        }   
        cx[i] = 0;   
        backtrack(i+1);
//搜索左子树
  
    }   
  
    
void
 printResult(){   
       cout << 
“可以装入的最大价值为:”
 << bestp << endl;   
       cout << 
“装入的物品依次为:”
;   
       
for
(
int
 i = 0; i < n; i++){   
         
if
(x[i] == 1)   
             cout << i+1 << 
” “
;   
       }   
       cout << endl;   
    }   
  

private
:   
   
double
 *p,*w;   
   
int
 n;   
   
double
 c;   
   
double
 bestp,cp,cw;
//最大价值，当前价值，当前重量
  
   
int
 *x,*cx;   
};   
  

int
 main(){   
　　
double
 p[4] = {9,10,7,4},w[4] = {3,5,2,1};   
    Knapsack ks = Knapsack(p,w,4,7);   
    ks.knapsack();   
　　ks.printResult();   
　　
return
 0;   
} 

    原文作者：回溯法
    原文地址: https://blog.csdn.net/Kevin_Samuel/article/details/8532145
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞