- 概念
- 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。
回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。
许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。
- 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。
- 基本思想
- 在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。（其实回溯法就是对隐式图的深度优先搜索算法）。
若用回溯法求问题的所有解时，要回溯到根，且根结点的所有可行的子树都要已被搜索遍才结束。
而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。
- 在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。（其实回溯法就是对隐式图的深度优先搜索算法）。
- 解题步骤
- （1）针对所给问题，确定问题的解空间：
首先应明确定义问题的解空间，问题的解空间应至少包含问题的一个（最优）解。
（2）确定结点的扩展搜索规则
（3）以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索
- （1）针对所给问题，确定问题的解空间：
- 子集树，排列数及其他
- 子集树概念：当所给问题是从n个元素的集合S中找出S满足的某种性质的子集时，相应的解空间树称为子集树。例如，0-1背包问题，要求在n个物品的集合S中，选出几个物品，使物品在背包容积C的限制下，总价值最大（即集合S的满足条件<容积C下价值最大>的某个子集）。
另：子集树是从集合S中选出符合限定条件的子集，故每个集合元素只需判断是否（0,1）入选，因此解空间应是一颗满二叉树
- 回溯法搜索子集树的一般算法
void backtrack(int t)//t是当前层数 { if(t>n)//需要判断每一个元素是否加入子集，所以必须达到叶节点，才可以输出 { output(x); } else { for(int i=0;i<=1;i++)//子集树是从集合S中，选出符合限定条件的子集，故每个元素判断是（1）否（0）选入即可（二叉树），因此i定义域为{0,1} { x[t]=i;//x[]表示是否加入点集，1表示是，0表示否 if(constraint(t)&&bound(t))//constraint(t)和bound(t)分别是约束条件和限定函数 { backtrack(t+1); } } } }
- 回溯法搜索子集树的一般算法
- 排列树概念：当问题是确定n个元素满足某种性质的排列时，相应的解空间称为排列树。排列树与子集树最大的区别在于，排列树的解包括整个集合S的元素，而子集树的解则只包括符合条件的集合S的子集。
- 回溯法搜索排列数的一般算法：
void backtrack(int t)//t是当前层数 { if(t>n)//n是限定最大层数 { output(x); } else { for(int i=t;i<=n;i++)//排列树的节点所含的孩子个数是递减的，第0层节点含num-0个孩子，第1层节点含num-1个孩子，第二层节点含num-2个孩子···第num层节点为叶节点，不含孩子。即第x层的节点含num-x个孩子，因此第t层的i，它的起点为t层数，终点为num，第t层（根节点为空节点，除外），有num-t+1个亲兄弟，需要轮num-t+1回 { swap(x[t],x[i]);//与第i个兄弟交换位置，排列树一条路径上是没有重复节点的，是集合S全员元素的一个排列，故与兄弟交换位置后就是一个新的排列 if(constraint(t)&&bound(t))//constraint(t)和bound(t)分别是约束条件和限定函数 { backtrack(t+1); } swap(x[i],x[t]); } } }
- 回溯法搜索排列数的一般算法：
- 非子集树，非排列数
- 递归算法
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); } } } }
- 递归算法
- 子集树概念：当所给问题是从n个元素的集合S中找出S满足的某种性质的子集时，相应的解空间树称为子集树。例如，0-1背包问题，要求在n个物品的集合S中，选出几个物品，使物品在背包容积C的限制下，总价值最大（即集合S的满足条件<容积C下价值最大>的某个子集）。
- 这类题目的解题方法：先根据题意去判断是什么类型的树（子集树，排列数，还是两者都不是），再去写代码。
- 实例详解
- 装载问题：有一批共n个集装箱要装上2艘载重量分别为c1和c2的轮船，其中集装箱i的重量为wi，且
，装载问题要求确定是否有一个合理的装载方案可将这些集装箱装上这2艘轮船。如果有，找出一种装载方案。
例如：当n=3,c1=c2=50,且w=[10,40,40]时，则可以将集装箱1和2装到第一艘轮船上，而将集装箱3装到第二艘轮船上；如果w=[20,40,40]，则无法将这3个集装箱都装上轮船。
基本思路： 容易证明，如果一个给定装载问题有解，则采用下面的策略可得到最优装载方案。
(1)首先将第一艘轮船尽可能装满；
(2)将剩余的集装箱装上第二艘轮船。
将第一艘轮船尽可能装满等价于选取全体集装箱的一个子集，使该子集中集装箱重量之和最接近C1。由此可知，装载问题等价于以下特殊的0-1背包问题。- 解题思路：画出解题思路图，得出这个解应该是一个子集树（0000,0001,0010,0011等等）。采用子集树的递归算法进行求解即可。
- 代码：
#include "stdafx.h" #include <iostream> using namespace std; template <class Type> class Loading { //friend Type MaxLoading(Type[],Type,int,int []); //private: public: void Backtrack(int i); int n, //集装箱数 *x, //当前解 *bestx; //当前最优解 Type *w, //集装箱重量数组 c, //第一艘轮船的载重量 cw, //当前载重量 bestw, //当前最优载重量 r; //剩余集装箱重量 }; template <class Type> void Loading <Type>::Backtrack (int i); template<class Type> Type MaxLoading(Type w[], Type c, int n, int bestx[]); int main() { int n=3,m; int c=50,c2=50; int w[4]={0,10,40,40}; int bestx[4]; m=MaxLoading(w, c, n, bestx); cout<<"轮船的载重量分别为："<<endl; cout<<"c(1)="<<c<<",c(2)="<<c2<<endl; cout<<"待装集装箱重量分别为："<<endl; cout<<"w(i)="; for (int i=1;i<=n;i++) { cout<<w[i]<<" "; } cout<<endl; cout<<"回溯选择结果为："<<endl; cout<<"m(1)="<<m<<endl; cout<<"x(i)="; for (int i=1;i<=n;i++) { cout<<bestx[i]<<" "; } cout<<endl; int m2=0; for (int j=1;j<=n;j++) { m2=m2+w[j]*(1-bestx[j]); } cout<<"m(2)="<<m2<<endl; if(m2>c2) { cout<<"因为m(2)大于c(2),所以原问题无解！"<<endl; } return 0; } template <class Type> void Loading <Type>::Backtrack (int i)// 搜索第i层结点 { if (i > n)// 到达叶结点 { if (cw>bestw) { for(int j=1;j<=n;j++) { bestx[j]=x[j];//更新最优解 bestw=cw; } } return; } r-=w[i]; if (cw + w[i] <= c) // 搜索左子树 { x[i] = 1; cw += w[i]; Backtrack(i+1); cw-=w[i]; } if (cw + r > bestw) { x[i] = 0; // 搜索右子树 Backtrack(i + 1); } r+=w[i]; } template<class Type> Type MaxLoading(Type w[], Type c, int n, int bestx[])//返回最优载重量 { Loading<Type>X; //初始化X X.x=new int[n+1]; X.w=w; X.c=c; X.n=n; X.bestx=bestx; X.bestw=0; X.cw=0; //初始化r X.r=0; for (int i=1;i<=n;i++) { X.r+=w[i]; } X.Backtrack(1); delete []X.x; return X.bestw; }#include "stdafx.h" #include <iostream> using namespace std; template <class Type> class Loading { //friend Type MaxLoading(Type[],Type,int,int []); //private: public: void Backtrack(int i); int n, //集装箱数 *x, //当前解 *bestx; //当前最优解 Type *w, //集装箱重量数组 c, //第一艘轮船的载重量 cw, //当前载重量 bestw, //当前最优载重量 r; //剩余集装箱重量 }; template <class Type> void Loading <Type>::Backtrack (int i); template<class Type> Type MaxLoading(Type w[], Type c, int n, int bestx[]); int main() { int n=3,m; int c=50,c2=50; int w[4]={0,10,40,40}; int bestx[4]; m=MaxLoading(w, c, n, bestx); cout<<"轮船的载重量分别为："<<endl; cout<<"c(1)="<<c<<",c(2)="<<c2<<endl; cout<<"待装集装箱重量分别为："<<endl; cout<<"w(i)="; for (int i=1;i<=n;i++) { cout<<w[i]<<" "; } cout<<endl; cout<<"回溯选择结果为："<<endl; cout<<"m(1)="<<m<<endl; cout<<"x(i)="; for (int i=1;i<=n;i++) { cout<<bestx[i]<<" "; } cout<<endl; int m2=0; for (int j=1;j<=n;j++) { m2=m2+w[j]*(1-bestx[j]); } cout<<"m(2)="<<m2<<endl; if(m2>c2) { cout<<"因为m(2)大于c(2),所以原问题无解！"<<endl; } return 0; } template <class Type> void Loading <Type>::Backtrack (int i)// 搜索第i层结点 { if (i > n)// 到达叶结点 { if (cw>bestw) { for(int j=1;j<=n;j++) { bestx[j]=x[j];//更新最优解 bestw=cw; } } return; } r-=w[i]; if (cw + w[i] <= c) // 搜索左子树 { x[i] = 1; cw += w[i]; Backtrack(i+1); cw-=w[i]; } if (cw + r > bestw) { x[i] = 0; // 搜索右子树 Backtrack(i + 1); } r+=w[i]; } template<class Type> Type MaxLoading(Type w[], Type c, int n, int bestx[])//返回最优载重量 { Loading<Type>X; //初始化X X.x=new int[n+1]; X.w=w; X.c=c; X.n=n; X.bestx=bestx; X.bestw=0; X.cw=0; //初始化r X.r=0; for (int i=1;i<=n;i++) { X.r+=w[i]; } X.Backtrack(1); delete []X.x; return X.bestw; }
- 装载问题：有一批共n个集装箱要装上2艘载重量分别为c1和c2的轮船，其中集装箱i的重量为wi，且
相关文章：