C语言算法之回溯法

回溯法

算法介绍

　　回溯法（Back Tracking Method）（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

基本思想

　　在回溯法中，每次扩大当前部分解时，都面临一个可选的状态集合，新的部分解就通过在该集合中选择构造而成。这样的状态集合，其结构是一棵多叉树，每个树结点代表一个可能的部分解，它的儿子是在它的基础上生成的其他部分解。树根为初始状态，这样的状态集合称为状态空间树。

　　回溯法对任一解的生成，一般都采用逐步扩大解的方式。每前进一步，都试图在当前部分解的基础上扩大该部分解。它在问题的状态空间树中， 从开始结点（根结点）出发，以 深度优先搜索整个状态空间。这个开始结点成为活结点，同时也成为当前的扩展结点。在当前扩展结点处，搜索向纵深方向移至一个新结点。这个新结点成为新的活结点，并成为当前扩展结点。如果在当前扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的活结点处，并使这个活结点成为当前扩展结点。回溯法以这种工作方式递归地在状态空间中搜索，直到找到所要求的解或解空间中已无活结点时为止。

　　回溯法与穷举法有某些联系，它们都是基于试探的。穷举法要将一个解的各个部分全部生成后，才检查是否满足条件，若不满足，则直接放弃该完整解，然后再尝试另一个可能的完整解，它并没有沿着一个可能的完整解的各个部分逐步回退生成解的过程。 而对于回溯法，一个解的各个部分是逐步生成的，当发现当前生成的某部分不满足约束条件时，就放弃该步所做的工作，退到上一步进行新的尝试，而不是放弃整个解重来。

算法框架

问题的解空间

　　应用回溯法求解问题时， 首先应明确定义问题的解空间，该解空间应 至少包含问题的一个最优解。例如，对于有n种物品的 0-1 背包问题，其解空间由长度为n的 0-1 向量组成，该解空间包含了对变量的所有可能的0-1 赋值。当 n=3 时，其解空间是{ (0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1) }

　　在定义了问题的解空间后，还需要将解空间有效地组织起来，使得回溯法能方便地搜索整个解空间，通常将 解空间组织成树或图的形式。例如，对于n= 3的0-1 背包问题，其解空间可以用一棵完全二叉树表示，从树根到叶子结点的任意一条路径可表示解空间中的一个元素，如从根结点A到结点J的路径对应于解空间中的一个元素(1, 0, 1)。

回溯法解题的关键要素

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

运用回溯法解题的关键要素有以下三点：

1.  针对给定的问题，定义问题的解空间；
2.  确定易于搜索的解空间结构；
3.  以深度优先方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。

递归和迭代回溯

一般情况下可以用递归函数实现回溯法，递归函数模板如下：

void BackTrace(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))
                BackTrace(t+1);
        }
}

　　其中，t 表示递归深度，即当前扩展结点在解空间树中的深度；n 用来控制递归深度，即解空间树的高度。当 t>n时，算法已搜索到一个叶子结点，此时由函数Output(x)对得到的可行解x进行记录或输出处理。用 f(n, t)和 g(n, t)分别表示在当前扩展结点处未搜索过的子树的起始编号和终止编号；h(i)表示在当前扩展结点处x[t] 的第i个可选值；函数 Constraint(t)和 Bound(t)分别表示当前扩展结点处的约束函数和限界函数。若函数 Constraint(t)的返回值为真，则表示当前扩展结点处x[1:t] 的取值满足问题的约束条件；否则不满足问题的约束条件。若函数Bound(t)的返回值为真，则表示在当前扩展结点处x[1:t] 的取值尚未使目标函数越界，还需由BackTrace(t+1)对其相应的子树做进一步地搜索；否则，在当前扩展结点处x[1:t]的取值已使目标函数越界，可剪去相应的子树。

　　采用迭代的方式也可实现回溯算法，迭代回溯算法的模板如下：

void IterativeBackTrace(void) {
    int t = 1;
    while(t>0) {
        if(f(n, t) <= g( n, t))
            for(int i = f(n, t); i <= g(n, t); i++ ) {
                x[t] = h(i);
                if(Constraint(t) && Bound(t)) {
                    if ( Solution(t))
                        Output(x);
                    else
                        t++;
                }
            }
            else t−−;
    }
}

　　在上述迭代算法中，用Solution(t)判断在当前扩展结点处是否已得到问题的一个可行解，若其返回值为真，则表示在当前扩展结点处x[1:t] 是问题的一个可行解；否则表示在当前扩展结点处x[1:t]只是问题的一个部分解，还需要向纵深方向继续搜索。用回溯法解题的一个显著特征是问题的解空间是在搜索过程中动态生成的，在任何时刻算法只保存从根结点到当前扩展结点的路径。如果在解空间树中，从根结点到叶子结点的最长路径长度为 h(n)，则回溯法所需的计算空间复杂度为 O(h(n))，而显式地存储整个解空间复杂度则需要O(2h(n))或O(h(n)!)。

子集树与排列树

　　当给定的问题是从n个元素的集合S中找出满足某种性质的子集时，相应的解空间树称为子集树。例如，n个物品的0-1 背包问题所对应的解空间树是一棵子集树，该类树通常有2n个叶子结点，总结点数为2n+1- 1，遍历子集树的任何算法需要的计算时间复杂度均为O(2n)。

　　回溯法搜索子集树的一般算法描述如下：

void BackTrace(int t) {
    if(t>n)
        Output(x);
    else
        for(int i = 0; i <= n; i++) {
            x[t] = i;
            if(Contraint(t) && Bound(t))
                BackTrace (t + 1);
        }
}

　　当给定的问题是确定 n 个元素满足某种性质的排列时，对应的解空间树称为排列树。排列树通常有n! 个叶子结点，遍历排列树需要的计算时间复杂度为O(n!)。

　　回溯法搜索排列树的算法模板如下：

void BackTrace(int t) {
    if(t>n)
        Output(x);
    else
        for(int i = 0; i <= n; i++) {
            Swap(x[t], x[i]);
            if(Contraint (t) && Bound (t))
                BackTrace(t + 1);
            Swap(x[t], x[i]);
        }
}

实例

算法框架

 

 01背包问题

问题描述：

链接：http://lx.lanqiao.cn/problem.page?gpid=T287

问题描述

　　给定N个物品,每个物品有一个重量W和一个价值V.你有一个能装M重量的背包.问怎么装使得所装价值最大.每个物品只有一个.

输入格式

　　输入的第一行包含两个整数n, m，分别表示物品的个数和背包能装重量。
　　以后N行每行两个数Wi和Vi,表示物品的重量和价值

输出格式

　　输出1行，包含一个整数，表示最大价值。

样例输入

3 5
2 3
3 5
4 7

样例输出

8

数据规模和约定

　1<=N<=200,M<=5000.

思路：

01背包属于找最优解问题，用回溯法需要构造解的子集树。对于每一个物品i，对于该物品只有选与不选2个决策，总共有n个物品，可以顺序依次考虑每个物品，这样就形成了一棵解空间树： 基本思想就是遍历这棵树，以枚举所有情况，最后进行判断，如果重量不超过背包容量，且价值最大的话，该方案就是最后的答案。

• 在搜索状态空间树时，只要左子节点是可一个可行结点，搜索就进入其左子树。对于右子树时，先计算上界函数，以判断是否将其减去（剪枝）。
• 上界函数bound():当前价值cw+剩余容量可容纳的最大价值<=当前最优价值bestp。　
• 为了更好地计算和运用上界函数剪枝，选择先将物品按照其单位重量价值从大到小排序，此后就按照顺序考虑各个物品

分析：

 

我们来根据这个图来分析基本的思路：首先我们有5个排好序了的（按单位重量价值排序）商品{【7,15】，【8,14】，【3,5】，【9,14】，【6,8】}，根据我们上面的思路，首先就因该将【7,15】装入背包，然后继续右节点下去，发现【8,14】这个元素背包装不下了，于是进行下一个判断，从右节点进入，因为已经判断好了【8,14】这个元素装不下去，所以我们直接从他的下一个元素进入【3,5】，然后就进入了上界函数了。

double bound(int t){
    // 计算最优价值的函数,也是上界函数，其功能为剪枝
     int leftW = W - Wsum;    //剩余书包能装下的重量
     double preV = Vsum;        // 当前的总价值
     while(t<=N && a[t][0]<= leftW){
         leftW -= a[t][0];
         preV += a[t][1];
         t++;
     } 
     if(t<= N){
         preV += (a[t][1]/(a[t][0]*1.0))*leftW;
     }
     return preV;
    
} 

 在上界函数中，我们判断当前背包的总价值Vsum加上背包剩余容量可容纳的最大价值是不是小于等于当前的最佳价值，进去之后等到剩余背包容量为5，然后判断是不是大于最后的一个物品了，假如不大于的话，判断是否能装下，如果不能的话并且还不大于最后的物品序号，那么当前总价值就是当前这个物品的单位重量价值* 背包余量加上之前的当前总价值，这里为什么要这么加上单位价值*背包余量呢，就是因为需要跳过装不下的物品，继续向下搜索。注意：在这代码中当前最佳价值永远是0。

代码：

# include <iostream>
using namespace std;
/*
对于左右节点来说，左节点代表着不将物品装入书包；
而右节点是将物品装进书包，对于每个物品来说都有这两种选择
所以由此可以构成一个完全二叉树结构 
*/
int N, W;            // N:物品总数，W：代表能承受的总量 
int a[201][2];                // 0：表示重量；1：表示价值 
int Vsum = 0, Wsum = 0;      // 统计总体积和总的物品价值
double bestV = 0.0 ;     // 表示最优的价值，也就是当前最佳组合的价值 
void sort(){
    // 冒泡排序，使单位重量价值最大的物品放在最前面 
    for(int i=1; i<=N; i++){
        for(int j=i+1; j<=N; j++){
            if(float(a[i][1] / (a[i][0]*1.0)) < float(a[j][1] / (a[j][0]*1.0))){
                int temp[1][2];
                temp[0][0] = a[i][0];
                temp[0][1] = a[i][1];
                a[i][0] = a[j][0];
                a[i][1] = a[j][1];
                a[j][0] = temp[0][0];
                a[j][1] = temp[0][1];
            }
        }
    }
         
}
double bound(int t){
    // 计算最优价值的函数,也是上界函数，其功能为剪枝
     int leftW = W - Wsum;    //剩余书包能装下的重量
     double preV = Vsum;        // 当前的总价值
     while(t<=N && a[t][0]<= leftW){
         leftW -= a[t][0];
         preV += a[t][1];
         t++;
     } 
     if(t<= N){
         preV += (a[t][1]/(a[t][0]*1.0))*leftW;
     }
     return preV;
    
} 
void backtrack(int t){            // 这里t代表第几个物品 
    if(t > N){        // 当t大于总物品的数量时，递归就结束了 
        bestV = Vsum;    // 最佳价值就等于目前的总价指数
        return ;    
    }
    // 计算右节点能不能装下，能装就装 
    if(Wsum+a[t][0] <= W){        // 如果书包能装的下就装下去 
        Wsum += a[t][0];    // 每次从右节点开始累加，也就是每次都要选择装下物品
        Vsum += a[t][1];
        backtrack(t+1);         // 然后继续深度搜索下一个节点
        Wsum -= a[t][0];        // 当下一次书包装不下的时候而且他的总价值还不是最优的，把上一次装的拿出来。 
        Vsum -= a[t][1];
    } 
    // 这里判断左节点，因为在t这个位置已经判断他不装进去了，所以用上一时刻的最优价值加上t下一个物品的
    // 价值大于当前最优价值的话，就从左节点下去 
    if(bound(t+1) > bestV){
        backtrack(t+1);
    }
} 

void Print(){
    for(int i=1; i<=N; i++){
        cout<< a[i][0]<< " "<< a[i][1]<< endl;
    }
}
int main(){
    cin >> N >> W;
    for(int i=1; i<=N; i++)
        cin>> a[i][0]>> a[i][1];
    sort();
    backtrack(1);    // 回溯函数 
//    Print();
//    cout<< "bestV:"<< bestV<< endl;
    cout<< bestV<< endl;
    return 0;
} 

三羊献瑞（2015年蓝桥杯第3题）

问题描述

链接：https://blog.csdn.net/softwareldu/article/details/45022413

观察下面的加法算式：

      祥 瑞 生 辉
  +   三 羊 献 瑞
-------------------
   三 羊 生 瑞 气

其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。

答案：first:9567 second:1085 sum:10652

思路分析：

将祥瑞生辉和三羊献瑞还有三羊生瑞气用分别用字母表示祥瑞生辉用：abcd表示，三羊献瑞用：efgb表示，三羊生瑞气用：efcbh表示，注意相同的汉字使用相同的字母表示的，那现在用上面的框架来试试这个代码是怎么写的了。首先确定这里有8个字母，是用0-9 10个数字组成的，那么我们应该先定义一个一位数组里面存放这8个数据，和一些变量i=1,g什么的，按照模板上说，先来一个for，给一个限定条件，控制g的值（g是一个表示数据），那这个条件是什么呢？就是判断当前的数是不是与之前的数相等，因为数据是不能重复，重复了的话就设置g=0；否则设置g=1；如果g=1的话，则继续下一步，判断g&&i==7，如果这个条件满足了的话就打印出数据，记住这是数组中的数，要进行处理在输出；然后接下来则要继续进行的就是判断i是不是走到底了，也就是7，i==7就代表已经走到底部了，如果还是小于7的话就是代表还有数组没有赋值，则在这里先i++（注意一定小于7，因为在下面有执行一遍i++了），然后在跟这个数据附一个初值，然后下面的就不用走了；接下来的一部f分就是回溯了，也就是当a[x]取得最大值的时候在这里是9，这时候a[x]增加不了了，并且这个时候i还是大于0的这个时候就要考虑是不是要退一步去更改上面的数据了，并且要用上while因为可能在回溯的时候不只是退一步，可能退几步；在接下来就是判断a[x]是不是达到最大值，并且这时候i==0了，如果是这种情况则，没有可回溯的条件了，程序就可以退出来；如果那个条件没有满足的话则对a[x]进行自增，大致流程就是这样。

总结详细：

1. 利用for对数据进行去重操作
2. 当满足条件i到达了底部时候，这时就可以进行输出、标记操作了
3. 当i没有到达底部，就可以产生新数据了
4. 判断某个数据是不是到达了极限，也就是数据是不是到达最大值了，并且i是大于0的，满足条件的话就可以进行回溯操作
5. 当数据到达了极限并且i==0，程序就可以退出了
6. 最后一步就是进行数据的自增了

代码：

#include <iostream>
using namespace std;
int main(){
    int bcde,fegh,bcgei;
    int a[8];
    int i,k,g;
    i = 0;
    a[i] = 0;
    while(1){
        for(g = 1,k = i -1;k >=0;k--){
            if(a[i] == a[k]) g = 0;
        }
        if(g&& i==7){
            bcde = a[0]*1000 + a[1]*100 + a[2]*10 + a[3];
            fegh = a[4]*1000 + a[3]*100 + a[5]*10 + a[6];
            bcgei = a[0]*10000 + a[1]*1000 +a[5]*100 + a[3]*10 + a[7];
            if((a[0] !=0 && a[4] != 0)&&(bcde + fegh ==bcgei)){
                cout << bcde << " " << fegh << " " << bcgei << endl;
            }
        }
        if(g && i < 7){
            i++;
            a[i] = 0;
            continue;
        }
        while(a[i] == 9&& i>0) i--;
        if(a[i] == 9&&i ==0) break;
        else 
        a[i]++;
        
        
    }
     
    return 0;
}

 

 参考资料：

百度百科

https://blog.csdn.net/qian2213762498/article/details/79420269