Day2-2021.1.10 背包问题的学习+整理。little。

2021年1月10日 时间都去哪了？

今日计划：力扣题目刷到150。javaweb进行下去，或者学习计算机网络。

今日工作：力扣题目刷到147。主要是背包问题还挺难搞？？？
1.背包问题的学习+整理。
2.416. 分割等和子集
3.解决了Typora笔记上传到CSDN的图片失效问题。
4.逛县城。试做小火锅，经验++。傍晚跑步

今日总结：
在家的效率是打了大大的折扣。
年前补基础，年后找实习。✔

今日语录：
女作家多丽丝·莱辛在《幸存者回忆录》中，写过这样一段话：
“我们浪费自己的健康，去赢得个人的财富，然后又浪费自己的财富，去重建自己的健康。
“我们焦虑地憧憬着未来，忘记了眼前的生活，活得既不是为了现在，也不是为了未来。
“我们活得似乎永远不会死，我们死得好像从来没活过。”

明天计划：整理背包问题的笔记。力扣题目刷到150+。
明天是新的一周了。下周刷题20道。力扣到达170。开始学习项目吧。
可以研读一下：大雪菜的背包九讲+也可以加入大雪菜的寒假刷题班5元

转到2021.1.9-2021.1.31的learning record 首页

[9 5.mp4]

0-1背包问题 视频教程

相关问题
「力扣」上的 0-1 背包问题：

「力扣」第 416 题：分割等和子集（中等）；
「力扣」第 474 题：一和零（中等）；
「力扣」第 494 题：目标和（中等）；
「力扣」第 879 题：盈利计划（困难）；
「力扣」上的 完全背包问题：

「力扣」第 322 题：零钱兑换（中等）；
「力扣」第 518 题：零钱兑换 II（中等）；
「力扣」第 1449 题：数位成本和为目标值的最大数字（困难）。
这里要注意鉴别：「力扣」第 377 题，不是「完全背包」问题。

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/0-1-bei-bao-wen-ti-xiang-jie-zhen-dui-ben-ti-de-yo/

贪心算法：优先放入平均价值最高的物品。

本题通过实际的案例，发现在这里贪心算法不可以得到全局最优解。

通过背包问题，引入动态规划的解决办法。

背包容量c固定，具有重量和价值特征的n种物品，挑出0-n个物品，装进背包，使得背包装入的物品总价值最高。

上图表示了0-1背包问题的状态转移方程。

F(n,c)：将n个物品装进容量为c的背包，使得价值最大。

F(i,c)=max( F(i-1,c) , v(i) + F( i-1,c- w(i) ) )

F(i-1,c)：第i个物品不放进背包中。

F( i-1,c- w(i) ) ：第i个物品放进背包中，相应的，当前的背包容量=背包容量 - 物品i的重量w(i)。

（1）递归方法

public class p9_ex5_1_1 {
    public int knapsack01(int[] w, int[] v, int C) {
        int n = w.length;
        //用[0,1,... ...,index]的物品来填充体积为c的背包的最大价值
        // n-1 是说 物品 0到n-1
        return bestValue(w, v, n - 1, C);
    }

    private int bestValue(int[] w, int[] v, int index, int c) {
        // 边界条件
        // 在调用过程中，index是逐渐减少的，容量c也是逐渐减少的。
        if (index < 0 || c < 0) {
            return 0;
        }
        //第index个物品不放入背包里。
        int res = bestValue(w, v, index - 1, c);
        // 判断剩余容量与w[index] 判断第 index 个物品的体积是否 小于等于背包的剩余容量。
        // 否则直接返回上面得到的res。
        if (w[index] <= c) {
            //第index个物品放入背包里。
            res = Math.max(res, v[index] + bestValue(w, v, index - 1, c - w[index]));
        }
        return res;
    }
}

（2）记忆搜索

import java.util.Arrays;

// 记忆化搜索
public class p9_ex5_1_1_1 {
    int[][] memo;

    public int knapsack01(int[] w, int[] v, int C) {
        int n = w.length;
        // 这里的初始化 容量是 从0到c,是c+1个数。
        memo = new int[n][C + 1];
        for (int i = 0; i < n; i++) {
            Arrays.fill(memo[i], -1);
        }
        //用[0,1,... ...,index]的物品来填充体积为c的背包的最大价值
        // n-1 是说 物品 0到n-1
        return bestValue(w, v, n - 1, C);
    }

    private int bestValue(int[] w, int[] v, int index, int c) {
        // 边界条件
        // 在调用过程中，index是逐渐减少的，容量c也是逐渐减少的。
        if (index < 0 || c < 0) {
            return 0;
        }
        if (memo[index][c] != -1) {
            return memo[index][c];
        }
        //第index个物品不放入背包里。
        int res = bestValue(w, v, index - 1, c);
        // 判断剩余容量与w[index] 判断第 index 个物品的体积是否 小于等于背包的剩余容量。
        // 否则直接返回上面得到的res。
        if (w[index] <= c) {
            //第index个物品放入背包里。
            res = Math.max(res, v[index] + bestValue(w, v, index - 1, c - w[index]));
        }
        memo[index][c] = res;
        return res;
    }
}

（3）动态规划

import java.util.Arrays;

public class p9_ex5_3 {
    public static void main(String[] args) {
        int[] w = new int[]{1, 2, 3};
        int[] v = new int[]{6, 10, 12};
        int c = 5;
        System.out.println(knapsack01(w, v, c));
    }

    private static int knapsack01(int[] w, int[] v, int c) {
        int n = w.length;
        // 没有可供选择的物品
        if (n == 0) {
            return 0;
        }
        // c+1是为了遍历0到c这些重量。 c+1 个元素 遍历列元素。
        int[][] dp = new int[n][c + 1];
        // dp 第0行的元素是多少。
        // 因为下面的下面的双重for循环会使用i-1，所有先去计算得到i=0的数据。
        // dp[0][j] 是说考虑放入第0件物品。如果剩余容量≥w[0]，则可以放入。
        for (int j = 0; j <= c; j++) {
            // 如果剩余容量j≥第0个物品的重量，那就可以将第0个物品放入背包，此时背包的价值为v[0]
            // 三目运算符
            dp[0][j] = j >= w[0] ? v[0] : 0;
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= c; j++) {
                // dp[i][j]是指考虑0到i这些物品，且容积为j的背包，所得到的最大值是多少。
                // 1.不考虑第i件物品。
                dp[i][j] = dp[i - 1][j];
                // 剩余的容量j仍然可以将重量为w[i]的物品装进去。
                if (j >= w[i]) {
                    dp[i][j] = Math.max(dp[i][j], v[i] + dp[i - 1][j - w[i]]);
                }
            }
        }
        // dp初始化大小为[n][c+1]
        return dp[n - 1][c];
    }
}

[9 6.mp4]

（4）背包问题的优化

F(i,c)=max( F(i-1,c) , v(i) + F( i-1,c- w(i) ) )

F(i-1,c)：第i个物品不放进背包中。

F( i-1,c- w(i) ) ：第i个物品放进背包中，相应的，背包容量-物品i的重量w(i)。

第i行元素，只是依赖于第i-1行元素，因此理论上只保留两行元素即可。

代码如下：

public class p9_ex5_3_2_1 {
    public static void main(String[] args) {
        int[] w = new int[]{1, 2, 3};
        int[] v = new int[]{6, 10, 12};
        int c = 5;
        System.out.println(knapsack01(w, v, c));
    }

    private static int knapsack01(int[] w, int[] v, int c) {
        int n = w.length;
        if (n == 0) {
            return 0;
        }
        // 第i行元素，只是依赖于第i-1行元素，因此理论上只保留两行元素即可。
        int[][] dp = new int[2][c + 1];
        for (int j = 0; j <= c; j++) {
            dp[0][j] = j >= w[0] ? v[0] : 0;
        }
        // i j 还是正常的去遍历。但是dp的空间是限制在了两行元素。
        // dp[行的索引i或者i-1 % 2]
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= c; j++) {
                dp[i % 2][j] = dp[(i - 1) % 2][j];
                if (j >= w[i]) {
                    dp[i % 2][j] = Math.max(dp[i % 2][j], v[i] + dp[(i - 1) % 2][j - w[i]]);
                }
            }
        }
        return dp[(n - 1) % 2][c];
    }
}

[视频9-6 15min30s讲到了 0-1背包问题的变种]

但是并没有详细去引申。自己可以去研读一下：大雪菜的背包九讲+也可以加入大雪菜的寒假刷题班5元。但是实际面试应该够了，不会考的很深。

（1）完全背包问题

完全背包问题：每个物品可以无限次的使用。这里由于背包的容量有限制，所以实际上每个物品的个数也会被限制，所以可以将完全背包问题转化为0-1背包问题。

（2）多重背包问题

多重背包问题：每个物品不止1个，而是有num[i]个。感觉就是上面问题的拓展延伸。

（3）多维费用的背包问题

多维费用的背包问题：考虑体积和重量两个维度

（4）等等变形的问题

[9 7.mp4]

416. 分割等和子集

对上面图片的解释：

题目要求：给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。那这样两个子集的元素和相等，那么所有元素遍历求和，除以2，得到目标值。目标值需要是整数。sum%2!=0

F（n，c）这里的c=sum/2。F（n，c）是将n个物品填满容量为c的背包。

F（i，c）=F（i-1，c）||F（i-1，c-w（i））。||的解释：因为要求结果是布尔值，那么只要这两个条件中一条满足，即可返回true。

F（i-1，c）是说第i个物品不装进背包。

F（i-1，c-w（i））是说将第i个物品装进背包。

伪代码：

1.遍历数组元素求和，sum%2!=0

2.边界条件：sum=0.sum<0.index<0.

3.业务代码

4.实际上，你考虑：sum/2在一个业务代码中满足了，那么剩余的元素和肯定也是sum/2。

（1）递归方法

递归会超时。

public class p9_ex7_416 {
    //用[0,......,index]的数组填充容量为sum的背包
    public boolean canPartition(int[] nums) {
        int n = nums.length;
        int sum = 0;
        // 首先，对输入的数组进行遍历求和。如果sum是偶数，则可以继续，否则直接返回false。
        for (int i = 0; i < n; i++) {
            sum = sum + nums[i];
        }
        // 如果sum不是偶数。那么就不能被平分。
        if (sum % 2 != 0) {
            return false;
        }
        // n-1 是对0到n-1的物品进行处理。
        // tryPartition解决了 0到n-1的物品 能否填充 sum/2 的背包。
        return tryPartition(nums, n - 1, sum / 2);
    }

    // 这里是使用nums[0...index]的物品，看是否能够完全填充一个容量为sum的背包
    private boolean tryPartition(int[] num, int index, int sum) {
        // 边界条件
        if (sum == 0) {
            return true;
        }
        // 边界条件
        if (sum < 0 || index < 0) {
            return false;
        }
        // 业务代码 F（i，c）=F（i-1，c）||F（i-1，c-w（i））
        //F（i-1，c）是说第i个物品不装进背包。
        //F（i-1，c-w（i））是说将第i个物品装进背包。
        return tryPartition(num, index - 1, sum) || tryPartition(num, index - 1, sum - num[index]);
    }
}

（2）记忆化搜索

import java.util.Arrays;

public class p9_ex7_416 {
    //memo[index][sum]用[0,......,index]的数组填充容量为sum的背包,是否可以填满
    //-1表示未填充，0表示填充不满，1表示可以填充
    int[][] memo;

    //用[0,......,index]的数组填充容量为sum的背包
    public boolean canPartition(int[] nums) {
        int n = nums.length;
        int sum = 0;

        // 首先，对输入的数组进行遍历求和。如果sum是偶数，则可以继续，否则直接返回false。
        for (int i = 0; i < n; i++) {
            sum = sum + nums[i];
        }
        // 如果sum不是偶数。那么就不能被平分。
        if (sum % 2 != 0) {
            return false;
        }
        memo = new int[n][sum / 2 + 1];
        for (int i = 0; i < n; i++) {
            Arrays.fill(memo[i], -1);
        }
        // n-1 是对0到n-1的物品进行处理。
        // tryPartition解决了 0到n-1的物品 能否填充 sum/2 的背包。
        return tryPartition(nums, n - 1, sum / 2);
    }

    // 这里是使用nums[0...index]的物品，看是否能够完全填充一个容量为sum的背包
    private boolean tryPartition(int[] num, int index, int sum) {
        // 边界条件
        if (sum == 0) {
            return true;
        }
        // 边界条件
        if (sum < 0 || index < 0) {
            return false;
        }
        if(memo[index][sum] != -1)
            return memo[index][sum]==1?true:false;
        memo[index][sum]=(tryPartition(nums,index-1,sum)||tryPartition(nums,index-1,sum-nums[index]))==true?1:0;
        return tryPartition(nums,index-1,sum)||tryPartition(nums,index-1,sum-nums[index]);  
    }
}

性能还是差一点。

（3）动态规划

这个是看的力扣的题解：+感觉比视频要好理解的多。

其实我还是感觉记忆化搜索比动态规划容易理解。

public class p9_ex7_416_1_1_1 {
    public static void main(String[] args) {
        int[] nums = new int[]{1, 5, 11, 5};
        System.out.println(canPartition(nums));
    }

    public static boolean canPartition(int[] nums) {
        int n = nums.length;
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += nums[i];
        }
        if (sum % 2 != 0) {
            return false;
        }
        int c = sum / 2;
        // 这里的数组初始化后，默认值是false。
        boolean[][] dp = new boolean[n][c + 1];
        // 因为下面的句子会用到dp[i - 1][j]。所以先填表格第 0 行，第 1 个数只能让容积为它自己的背包恰好装满
        if (nums[0] <= c) {
            dp[0][nums[0]] = true;
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= c; j++) {
                //不将第i件物品装进背包。
                dp[i][j] = dp[i - 1][j];
                // 下面的if可以删掉，不影响结果。
                if (nums[i] == j) {
                    dp[i][j] = true;
                    continue;
                }
                // 剩余容量可以装入第i件物品
                if (nums[i] < j) {
                    dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]];
                }
            }
        }
        return dp[n - 1][c];
    }
}

[3