使用回溯法求解装载问题
回溯法解决装载问题（java实现）
-
问题描述：有n个集装箱要装上两艘载重量分别为C1和C2的轮船，其中集装箱i的重量为wi，且：∑ wi ≤ C1+C2。 求是否有一个合理的装载方案能将这 n 个集装箱装上这两艘轮船。
-
分析：假设wt 为装上第一艘轮船的集装箱的重量之和。此时，如果有
，则问题有解；否则问题无解。所以，该问题是在 wt ≤ C1的前提下，寻找 wt 最大值，使得C1 -wt 尽量小，等价于如何将第一艘轮船尽可能装满。而如何将第一艘轮船尽可能装满等价于选取全体集装箱的一个子集，使该子集中集装箱的重量之和最接近C1。所以该问题可以形式化描述为
设有3个集装箱要装上两艘重量分别为C1和C2的轮船，C1=C2=30，w={16,15,15}。问是否有一个合理的方案能将这3个集装箱装上两艘船？采用回溯法求解该问题。
1. 定义问题的解空间
对于有3个集装箱要装上轮船的装载问题，其解空间由长度为3的0-1向量即{(0,0,0),(0,0,1),(0,1,0),(0,1,1),(1,0,0),(1,0,1),(1,1,0),(1,1,1)}组成。
2. 建立解空间结构
装载问题的解空间结构是一棵完全二叉树。解空间树中每个结点都有左右两个分支，左分支用1标识，表示把第 i 个集装箱放上轮船，右分支用0标识，表示不把集装箱 i 放上轮船。解空间树的第i层到第 i+1层边上的标号给出了变量的值，从树根到叶的任意一条路径表示解空间中的一个元素。例如，从根结点A到叶结点 L 的路径对应于解空间中的元素(0,1,1)。装载问题的解空间树如图所示。
3. 采用回溯法以深度优先的方式搜索解空间树
初始时结点A是活结点并且是当前的可扩展结点，结点A有2个子结点，即B和C。左分支用1标识，表示把集装箱1放上第一艘轮船， 右分支用0标识，不把集装箱1放上轮船。 结点A是根结点，根结点在第一层，i从1开始调用回溯算法框架，即使用函数backtrack(1)开始搜索进程。注意，此时除集装箱1外，岸上剩余集装箱(集装箱2和集装箱3)的重量之和为30 (r=30)。
在搜索过程中，为了加快搜索的进程，避免无效搜索，在进入左子树之前，需设置约束函数在扩展结点处剪去不满足的约束条件的子树；在进入右子树之前，需设置限界函数在扩展结点处剪去不能得到最优解的子树。首先检测左子树处是否满足约束条件。
如图：
用cw表示当前已放上轮船的集装箱的重量和，w[1]为集装箱 1 的重量，C1是第一艘轮船的载重。因为cw+w[1]≤C1，结点B满足约束条件，可以将集装箱1放上轮船，x[1]=1,cw=16。结点B成为活结点并成为当前可扩展结点，递归函数backtrack（2）开始向结点B的下一层进行搜索。以此类推，直到找到整个问题的最优解。
代码实现
package backtrack;
public class Loading {
int number; //集装箱的数量
int[] w; //集装箱重量数组，记录每个集装箱的重量
int c1; // 第一艘轮船的载重量
int cw; //当前的载重量
int bestw; // 当前最优载重量
int r; //剩余集装箱重量
int[] x; //当前解
int[] bestx; //当前最优解
public void maxLoading(int n,int[] ww,int cc) {
//初始化数据成员
w=ww;
c1=cc;// 第一艘轮船的载重量
cw=0;//当前的载重量
bestw=0;// 当前最优载重量
number=n;
x=new int[n+1];
bestx=new int[n+1];
for(int i=1;i<=n;i++) {
r+=w[i]; //初始化r
}
//调用backtrack(i)函数计算最优载重量
backtrack(1);
//输出最佳装载方案
System.out.println("最优装载方案为：");
for(int k=1;k<=n;k++) {
System.out.print(bestx[k]+" ");
}
System.out.println();
//输出最优装载量
System.out.println("最优装载量为："+bestw);
}
//回溯法实现求解最优装载问题
public void backtrack(int i){
//搜索第i层结点
if(i>number)
{
//到达叶节点
for(int j=1;j<=number;j++) {
bestx[j]=x[j];
}
bestw=cw;
return;
}
//搜索子树
r-=w[i];
if(cw+w[i]<=c1)
{
//搜索左子树
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];
}
public static void main(String[] args) {
int n=3;//集装箱的数量
int c=30;//第一艘轮船的载重量
int[] weight= {
0,16,15,15};//集装箱重量数组
Loading l=new Loading();
l.maxLoading(n,weight,c);
}
}
当然，在最后我们还得检验一下，在轮船1达到最优载重量时，剩余的集装箱总重量是否超出轮船2的载重量，如果超出，那么该问题仍是无解的。
package backtrack;
public class Loading {
int number; //集装箱的数量
int[] w; //集装箱重量数组，记录每个集装箱的重量
int totalWeight;//集装箱总重量
int c1; // 第一艘轮船的载重量
int c2; // 第二艘轮船的载重量
int cweight2;// 第二艘轮船需要装载的重量
int cw; //当前的载重量
int bestw; // 当前最优载重量
int r; //剩余集装箱重量
int[] x; //当前解
int[] bestx; //当前最优解
public void maxLoading(int n,int[] ww,int c1,int c2) {
//初始化数据成员
w=ww;
this.c1=c1;// 第一艘轮船的载重量
this.c2=c2;// 第一艘轮船的载重量
cweight2=0;
cw=0;//当前的载重量
bestw=0;// 当前最优载重量
number=n;
x=new int[n+1];
bestx=new int[n+1];
for(int i=1;i<=n;i++) {
r+=w[i]; //初始化r
totalWeight+=w[i]; //初始化totalWeight
}
//调用backtrack(i)函数计算最优载重量
backtrack(1);
//计算第二艘轮船需要的装载量
cweight2=totalWeight-bestw;
//输出最佳装载方案
if(cweight2<= c2) {
//如果第二艘轮船需要的装载量小于其载重量，则两艘轮船可以装载所有物品
System.out.println("可以装载所有货物！");
System.out.println("第一艘轮船的最优装载方案为：");
for(int k=1;k<=n;k++) {
System.out.print(bestx[k]+" ");
}
System.out.println();
//输出最优装载量
System.out.println("第一艘轮船的最优装载量为："+bestw);
System.out.println("第二艘轮船需要装载的重量为："+cweight2);
}
else {
System.out.println("无法装载所有货物！");
}
}
//回溯法实现求解最优装载问题
public void backtrack(int i){
//搜索第i层结点
if(i>number)
{
//到达叶节点
for(int j=1;j<=number;j++) {
bestx[j]=x[j];
}
bestw=cw;
return;
}
//搜索子树
r-=w[i];
if(cw+w[i]<=c1)
{
//搜索左子树
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];
}
public static void main(String[] args) {
int n=3;//集装箱的数量
int c1=30;//第一艘轮船的载重量
int c2=30;
int[] weight= {
0,16,15,15};//集装箱重量数组
Loading l=new Loading();
l.maxLoading(n,weight,c1,c2);
}
}