递归回溯
由于回溯法是对解空间的深度优先搜索，因此在一般情况下可用递归函数来实现回溯法如下：
t表示递归深度，即当前扩展节点在解空间树的深度。
n用来控制递归深度。当t>n时表示算法搜索到叶节点。
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);
}
}
迭代回溯
采用树的非递归深度优先遍列算法，可将回溯法表示为一个非递归迭代过程。
solution(t)判断当前扩展节点是否得到问题的可行解。
void iterativeBacktrack( )
{ 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--;
}
}
用回溯法搜索子集树的一般算法描述为：
void backtrack( int t )
{
if ( t>n )
output(x);
else
for( int i=0; i<=1; i++ ) {
x[t]=i;
if ( constraint(t)&&bound(t) )
backtrack(t+1);
}
}
用回溯法搜索排列树的一般算法描述为：
void backtrack( int t )
{
if ( t>n )
output(x);
else
for( int i=t; i<=n; i++ ) {
swap(x[t], x[i] );
if ( constraint(t)&&bound(t) )
backtrack(t+1);
swap(x[t], x[i] );
}
}
public class Loading
{
//类的数据成员
static int n; //集装箱数
static int[] w; //集装箱重量数组
static int c; //第一艘轮船的载重量
static int cw; //当前载重量
static int bestw; //当前最优载重量
public static int maxLoading ( int [] ww, int cc )
{ //初始化类数据成员
n=ww.length – 1; w=ww;
c=cc; cw=0; bestw=0;
//计算最优载重量
backtrack(1);
return bestw;
}
//回溯算法
private static void backtrack( int t )
{ //搜索第i层节点
if ( i>n ) { //到达叶节点
if (cw>bestw) bestw=cw;
return; }
//搜索子树
if (cw+w[I]<=c) { //搜索左子树，即x[i]=1
cw+=w[i];
backtrack(i+1);
cw-=w[i];
}
backtrack(t+1); //搜索右子树
}
}
public class Loading
{
//类的数据成员
static int n; //集装箱数
static int[] w; //集装箱重量数组
static int c; //第一艘轮船的载重量
static int cw; //当前载重量
static int bestw; //当前最优载重量
static int r; //剩余集装箱的重量
public static int maxLoading ( int [] ww, int cc )
{ //初始化类数据成员
n=ww.length – 1; w=ww; c=cc; cw=0; bestw=0;
//初始化
for(int i=1; i<=n; i++) r+=w[i];
//计算最优载重量
backtrack(1); return bestw;
}
//回溯算法
private static void backtrack( int t )
{ //搜索第i层节点
if ( i>n ) { //到达叶节点
if (cw>bestw) bestw=cw;
return; }
//搜索子树
r - = w[i];
if (cw+w[i]<=c) { //搜索左子树
cw+=w[i]; backtrack(i+1); cw -=w[i];
}
if (cw+w[i]>bestw) //搜索右子树
backtrack(t+1);
r + = w[i];
}
}
构造最优解
public class Loading
{ //类的数据成员
static int n; //集装箱数
static int[] w; //集装箱重量数组
static int c; //第一艘轮船的载重量
static int cw; //当前载重量
static int bestw; //当前最优载重量
static int r; //剩余集装箱的重量
static int[] x; //当前解
static int[] bestx; //当前最优解
public static int maxLoading ( int [] ww, int cc )
{ //初始化类数据成员
n=ww.length – 1; w=ww; c=cc; cw=0; bestw=0; x=new int[n+1]; bestx=xx;
//初始化
for(int i=1; i<=n; i++) r+=w[i];
//计算最优载重量
backtrack(1); return bestw;
}
//回溯算法
private static void backtrack( int t )
{ //搜索第i层节点
if ( i>n ) { //到达叶节点
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+w[i]>bestw) { //搜索右子树
x[i]=0; backtrack(t+1); }
r + = w[i];
}
迭代回溯
由于数组x记录了解空间从根节点至当前扩展节点的路径，这些信息已包含了回溯法所需的信息。利用数组x的信息可以改为非递归的形式。