背包九讲Java版本

package dp;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 背包九讲
 *
 * @ProjectName: algorithm
 * @Package: dp
 * @Description: TODO
 * @Author: bipa
 * @Date: 2022/1/8 8:00
 */
public class Pack {

    /**
     * 01背包（每样物品的数量为一个）
     *
     * @param n 物品样数
     * @param m 背包容量
     * @param v 物品体积
     * @param w 物品价值
     * @return 总体积不超过m的最大价值
     */
    public static int pack01(int n, int m, int[] v, int[] w) {
        int[] dp = new int[m + 1];
        for (int i = 0; i < n; i++) {
            for (int j = m; j >= v[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
            }
        }
        return dp[m];
    }

    /**
     * 01背包方案数
     *
     * @param n   物品数量
     * @param m   背包容量
     * @param v   物品体积
     * @param w   物品价值
     * @param mod 10^9 + 7
     * @return 最优选法的方案数
     */
    public static int getNumber(int n, int m, int[] v, int[] w, int mod) {
        int[] dp = new int[m + 1], num = new int[m + 1];
        Arrays.fill(dp, Integer.MIN_VALUE);
        num[0] = 1;
        dp[0] = 0;
        for (int i = 0; i < n; i++) {
            for (int j = m; j >= v[i]; j--) {
                int temp = Math.max(dp[j], dp[j - v[i]] + w[i]);
                int sum = 0;
                if (temp == dp[j]) {
                    sum += num[j];
                }
                if (temp == dp[j - v[i]] + w[i]) {
                    sum += num[j - v[i]];
                }
                if (sum >= mod) {
                    sum -= mod;
                }
                dp[j] = temp;
                num[j] = sum;
            }
        }
        int max = 0;
        for (int i = 0; i <= m; i++) {
            max = Math.max(max, dp[i]);
        }
        int res = 0;
        for (int i = 0; i <= m; i++) {
            if (max == dp[i]) {
                res += num[i];
                if (res >= mod) {
                    res -= mod;
                }
            }
        }
        return res;
    }

    /**
     * 01背包具体方案
     *
     * @param n    物品数量
     * @param m    背包容量
     * @param v    物品体积
     * @param w    物品价值
     * @param link 连接符
     * @return 最优选法的具体方案
     */
    public static String getPath(int n, int m, int[] v, int[] w, String link) {
        int[][] dp = new int[n + 1][m + 1];
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 0; j <= m; j++) {
                dp[i][j] = dp[i + 1][j];
                if (j >= v[i]) {
                    dp[i][j] = Math.max(dp[i][j], dp[i+1][j - v[i]] + w[i]);
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            if (dp[i][m] == dp[i+1][m- v[i]] + w[i]) {
                sb.append(link).append(i);
                m -= v[i];
            }
        }
        return sb.substring(1);
    }

    /**
     * 完全背包（每样物品的数量无限制）
     *
     * @param n 物品样数
     * @param m 背包容量
     * @param v 物品体积
     * @param w 物品价值
     * @return 总体积不超过m的最大价值
     */
    public static int packComplete(int n, int m, int[] v, int[] w) {
        int[] dp = new int[m + 1];
        for (int i = 0; i < n; i++) {
            for (int j = v[i]; j <= m; j++) {
                dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
            }
        }
        return dp[m];
    }

    /**
     * 多重背包（每样物品的数量为s）
     *
     * @param n 物品样数
     * @param m 背包容量
     * @param v 物品体积
     * @param w 物品价值
     * @param s 每样物品的数量
     * @return 总体积不超过m的最大价值
     */
    public static int packMultiple(int n, int m, int[] v, int[] w, int[] s) {
        int[] dp_I = new int[m + 1];
        for (int i = 0; i < n; i++) {
            for (int j = m; j >= v[i]; j--) {
                for (int k = 1; k <= s[i] && k * v[i] <= j; k++) {
                    dp_I[j] = Math.max(dp_I[j], dp_I[j - k * v[i]] + k * w[i]);
                }
            }
        }
        /**
         * 二进制优化，将每样物品的数量进行二进制拆分
         */
        int[] dp_II = new int[m + 1];
        class Goods {
            int v; // 体积
            int w; // 价值

            Goods(int v, int w) {
                this.v = v;
                this.w = w;
            }
        }
        List<Goods> goods = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int k = s[i];
            for (int j = 1; j <= k; j *= 2) {
                k -= j;
                goods.add(new Goods(j * v[i], j * w[i]));
            }
            if (k > 0) {
                goods.add(new Goods(k * v[i], k * w[i]));
            }
        }
        for (Goods g : goods) {
            for (int i = m; i >= g.v; i--) {
                dp_II[i] = Math.max(dp_II[i], dp_II[i - g.v] + g.w);
            }
        }
        return dp_I[m];
    }

    /**
     * 二维费用背包
     *
     * @param n 物品样数
     * @param V 背包体积
     * @param M 背包承受重量
     * @param v 物品体积
     * @param m 物品质量
     * @param w 物品价值
     * @return 总体积不超过V，总质量不超过M的最大价值
     */
    public static int packTwo(int n, int V, int M, int[] v, int[] m, int[] w) {
        int[][] dp = new int[V + 1][M + 1];
        for (int i = 0; i < n; i++) {
            for (int j = V; j >= v[i]; j--) {
                for (int k = M; k >= m[i]; k--) {
                    dp[j][k] = Math.max(dp[j][k], dp[j - v[i]][k - m[i]] + w[i]);
                }
            }
        }
        return dp[V][M];
    }

    /**
     * 分组背包（每组物品最多选一个）
     *
     * @param n 组的数量
     * @param m 背包容量
     * @param v 物品体积
     * @param w 物品价值
     * @return 总体积不超过m的最大价值
     */
    public static int packGroup(int n, int m, List<Integer>[] v, List<Integer>[] w) {
        int[] dp = new int[m + 1];
        for (int i = 0; i < n; i++) {
            for (int j = m; j >= 0; j--) {
                for (int k = 0; k < v[i].size(); k++) {
                    if (j >= v[i].get(k)) {
                        dp[j] = Math.max(dp[j], dp[j - v[i].get(k)] + w[i].get(k));
                    }
                }
            }
        }
        return dp[m];
    }


}