【剑指offer系列】-10背包问题（动态规划、数组压缩）

题目：0、1背包问题，完全背包问题

思路：

0、1背包问题就是拿还是不拿的问题
状态转印方程dp[i] [j]：第i个物品，背包容量为j时，背包能装下的最大价值

1.当前第i个物品的重量w[i] > j 大于了当前的背包容量；显然拿不了，因为装不下，所以此时背包中最大价值仍为第dp[i-1][j]
2.当前第i个物品的重量w[i] <= j 小于当前的背包容量时，需要做选择；
第一种，不拿，仍然保持现状，价值不增，但是背包容量也不会变小
第二种，拿，即将当前物品i重量为w[i]放入背包，价值增大v[i]（因为装入了第i个物品，其价值为v[i]），但是带来的影响是背包的容量相应的减小为：j-w[i]。所以要取这两种情况中值较大的,max(第一种，第二种)

输入：
10 4 ，其中10是背包容量，4是有四个物品
2 1 ，第一个物品的重量为2，价值为1
3 3
4 5
7 9 第四个物品的重量为7，价值为9

输出：12 代表容量为10的背包，能装下的最大价值

public class Main10_3
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        int n = sc.nextInt();
        int[] w = new int[n];
        int[] v = new int[n];
        for (int i = 0; i < n; i++)
        {
            w[i] = sc.nextInt();
            v[i] = sc.nextInt();
        }
        System.out.println(capacity_0(c, w, v, n));
        System.out.println(capacity_1(c, w, v, n));
        System.out.println(capacity_n(c, w, v, n));
    }

    /**
     * 0/1背包问题，0和1代表拿还是不拿的问题：每一件物品的数量有限，一开始就给定了物品的个数n
     *
     * @param c，背包的容量capacity
     * @param w，物品的重量weight
     * @param v，物品的价值value
     * @param n，物品的总共个数，四个物品总共
     * @return
     */
    private static int capacity_0(int c, int[] w, int[] v, int n)
    {
        if (c < 0 || w.length != v.length || w.length != n) return -1;
        if (c == 0) return 0;
        int[][] dp = new int[n + 1][c + 1];
        int[] ww = new int[n + 1];//要符合0行0列不参与计算，所以
        int[] vv = new int[n + 1];//数组相应的值也需要向后推一个，0的位置为0
        int index = 0;
        for (int i = 1; i < n + 1; i++)
        {
            ww[i] = w[index];
            vv[i] = v[index++];
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= c; j++)
            {
                if (ww[i] > j)
                {
                    dp[i][j] = dp[i - 1][j];
                } else if (ww[i] <= j)
                {
                    dp[i][j] = Math.max(dp[i - 1][j], vv[i] + dp[i - 1][j - ww[i]]);
                }
            }
        }
        return dp[n][c];
    }

    /**
     * 0/1背包问题，数组压缩后的解法
     * @param c
     * @param w
     * @param v
     * @param n
     * @return
     */
    private static int capacity_1(int c, int[] w, int[] v, int n)
    {
        if (c < 0 || w.length != v.length || w.length != n) return -1;
        if (c == 0) return 0;
        int[] dp = new int[c + 1];
        int[] ww = new int[n + 1];
        int[] vv = new int[n + 1];
        int index = 0;
        for (int i = 1; i < n + 1; i++)
        {
            ww[i] = w[index];
            vv[i] = v[index++];
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = c; j > 0; j--)//从后向前
            {
                if (ww[i] <= j)
                {
                    dp[j] = Math.max(dp[j], dp[j - ww[i]] + vv[i]);
                }
            }
        }
        return dp[c];
    }

    /**
     * 完全背包问题：同一件物品可以拿0次、1次、2次···，当前背包容量j/该物品单个重量w[i] 次
     * @param c
     * @param w
     * @param v
     * @param n，物品的总共种类，四种物品，每种物品个数无限多
     * @return
     */
    private static int capacity_n(int c, int[] w, int[] v, int n)
    {
        if (c < 0 || w.length != v.length || w.length != n) return -1;
        if (c == 0) return 0;
        int[] dp = new int[c + 1];
        int[] ww = new int[n + 1];
        int[] vv = new int[n + 1];
        int index = 0;
        for (int i = 1; i < n + 1; i++)
        {
            ww[i] = w[index];
            vv[i] = v[index++];
        }
        for (int i = 1; i <= n; i++)
        {
            for (int j = c; j > 0; j--)
            {
                for (int k = 0; k <= j / ww[i]; k++)//同一个物品拿0个，···,直到可以拿 当前背包容量/ww[i]该物品单个的重量
                {
                    dp[j] = Math.max(dp[j], k * vv[i] + dp[j - k * ww[i]]);
                }
            }
        }
        return dp[c];
    }
}