回溯法解决装载问题的四种方式

1.无上界函数：

/**
 * @author 042
 * @date 2020/5/23 19:53
 * @description  无上界函数
 */
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 i) {
        // 搜索第i层结点
        if (i > n) { // 到达叶节点
            if (cw > bestw) {
                bestw = cw;
            }
            return;
        }

        // 搜索子树
        if (cw + w[i] <= c) { // 搜索左子树
            cw += w[i];
            backtrack(i + 1);
            cw -= w[i];
        }
        backtrack(i + 1);
    }

    public static void main(String[] args) {
        int[] ww = {0,10,20,40,30};
        int cc = 60;
        int i = Loading.maxLoading(ww, cc);
        System.out.println(i);
    }
}

2.有上界函数：

/**
 * @author 042
 * @date 2020/5/23 20:30
 * @description 添加上界函数
 */
public class Loading2 {
    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;
        r = 0;

        for (int i = 1; i <= n; i++) {
            r += w[i];
        }

        // 计算最优载重数量
        backtrack(1);
        return bestw;
    }

    private static void backtrack(int i) {
        // 搜索第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 + r > bestw) {  // 搜索右子树
            backtrack(i + 1);
        }

        r += w[i];
    }

    public static void main(String[] args) {
        int[] ww = {0,10,20,40,30};
        int cc = 60;
        int i = Loading2.maxLoading(ww, cc);
        System.out.println(i);
    }
}

3.涵盖最优路径保存：

/**
 * @author 042
 * @date 2020/5/23 22:26
 * @description 有最优解路径保存
 */
public class Loading3 {
    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, int[] xx) {
        // 初始化类数据成员
        n = ww.length - 1;
        w = ww;
        c = cc;
        cw = 0;
        bestw = 0;
        r = 0;
        x = new int[n + 1];
        bestx = xx;

        // 初始化r
        for (int i = 1; i <= n; i++) {
            r += w[i];
        }

        backtrack(1);
        return bestw;
    }

    private static void 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];


    }

    public static void main(String[] args) {
        int[] ww = {0,10,20,40};
        int cc = 40;
        int[] xx = new int[ww.length];
        int i = Loading3.maxLoading(ww, cc, xx);
        System.out.println(i);
    }
}

4.迭代回溯：

/**
 * @author 042
 * @date 2020/5/23 23:26
 * @description 迭代回溯
 */
public class Loading4 {

    public static int maxLoading(int[] w, int c, int[] bestx) {
        // 迭代回溯法
        // 返回最优载重量及其相应解
        // 初始化根节点
        int i = 1; // 当前层
        int n = w.length - 1;
        int[] x = new int[n + 1]; // x[1:i-1]为当前路径
        int bestw = 0; // 当前最优载重量
        int cw = 0; // 当前载重量
        int r = 0; // 剩余集装箱重量

        for (int j = 1; j <= n; j++) {
            r += w[j];
        }

        while (true) {
            while (i <= n && cw + w[i] <= c) { // 进入左子树
                r -= w[i];
                cw += w[i];
                x[i] = 1;
                i ++;
            }

            if (i > n) { // 到达叶结点
                for (int j = 1; j < n; j++) {
                    bestx[j] = x[j];
                }
                bestw = cw;
            }else { // 进入右子树
                r -= w[i];
                x[i] = 0;
                i ++;
            }


            while (cw + r <= bestw) {//剪枝回溯
                i --;
                while (i > 0 && x[i] == 0) { // 从右子树返回
                    r += w[i];
                    i --;
                }
                if (i == 0) {
                    return bestw;
                }

                // 进入右子树
                x[i] = 0;
                cw -= w[i];
                i ++;
            }
        }
    }

    public static void main(String[] args) {
        int[] ww = {0,10,20};
        int cc = 20;
        int[] xx = new int[ww.length];
        int i = Loading4.maxLoading(ww, cc, xx);
        System.out.println(i);
    }

}