• 代码随想录算法训练营day46|139.单词拆分|多重背包基础理论| 背包总结


    139.单词拆分

    力扣题目链接

    给定一个非空字符串 s 和一个包含非空单词的列表 wordDict,判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

    说明:

    拆分时可以重复使用字典中的单词。

    你可以假设字典中没有重复的单词。

    示例 1:

    • 输入: s = “leetcode”, wordDict = [“leet”, “code”]
    • 输出: true
    • 解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。

    示例 2:

    • 输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
    • 输出: true
    • 解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。
    • 注意你可以重复使用字典中的单词。

    示例 3:

    • 输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]

    • 输出: false

    • 动态规划五部曲

    背包:字符串 长度为i

    物品:字典里的单词

    1.确定dp数组的含义

    dp[i]: 字符串的长度为i,dp[i]就为true

    2.确定递推公式

    如果我们这个[j,i]的区间出现在单词里,同时dp[j]为true,那么dp[i]=true

    if(wordDict.contains(s.substring(j,i))&&dp[j]){
         dp[i]=true;
    }
    
    • 1
    • 2
    • 3

    substring() 方法用于提取字符串中介于两个指定***下标*** 之间的字符。

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

    3.初始化

    dp[0]=true

    4.遍历顺序

    强调顺序,需要排列,先背包,后物品

    5.举例推导dp[i]

    以输入: s = “leetcode”, wordDict = [“leet”, “code”]为例,dp状态如图:

    139.单词拆分

    dp[s.size()]就是最终结果。

    动规五部曲分析完毕,代码如下

    class Solution {
        public boolean wordBreak(String s, List<String> wordDict) {
            boolean[] dp=new boolean[s.length()+1];
            dp[0]=true;
            for(int i=1;i<=s.length();i++){
                for(int j=0;j<i;j++){
                    if(wordDict.contains(s.substring(j,i))&&dp[j]){
                        dp[i]=true;
                    }
                }
            }
            return dp[s.length()];
        }
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    多重背包基础理论

    有N种物品和一个容量为V 的背包。第i种物品最多有Mi件可用,每件耗费的空间是Ci ,价值是Wi 。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量,且价值总和最大。

    多重背包和01背包是非常像的, 为什么和01背包像呢?

    每件物品最多有Mi件可用,把Mi件摊开,其实就是一个01背包问题了。

    例如:

    背包最大重量为10。

    物品为:

    重量价值数量
    物品01152
    物品13203
    物品24302

    问背包能背的物品最大价值是多少?

    和如下情况有区别么?

    重量价值数量
    物品01151
    物品01151
    物品13201
    物品13201
    物品13201
    物品24301
    物品24301

    毫无区别,这就转成了一个01背包问题了,且每个物品只用一次。

    public void testMultiPack1(){
        // 版本一:改变物品数量为01背包格式
        List<Integer> weight = new ArrayList<>(Arrays.asList(1, 3, 4));
        List<Integer> value = new ArrayList<>(Arrays.asList(15, 20, 30));
        List<Integer> nums = new ArrayList<>(Arrays.asList(2, 3, 2));
        int bagWeight = 10;
    
        for (int i = 0; i < nums.size(); i++) {
            while (nums.get(i) > 1) { // 把物品展开为i
                weight.add(weight.get(i));
                value.add(value.get(i));
                nums.set(i, nums.get(i) - 1);
            }
        }
    
        int[] dp = new int[bagWeight + 1];
        for(int i = 0; i < weight.size(); i++) { // 遍历物品
            for(int j = bagWeight; j >= weight.get(i); j--) { // 遍历背包容量
                dp[j] = Math.max(dp[j], dp[j - weight.get(i)] + value.get(i));
            }
            System.out.println(Arrays.toString(dp));
        }
    }
    
    public void testMultiPack2(){
        // 版本二:改变遍历个数
        int[] weight = new int[] {1, 3, 4};
        int[] value = new int[] {15, 20, 30};
        int[] nums = new int[] {2, 3, 2};
        int bagWeight = 10;
    
        int[] dp = new int[bagWeight + 1];
        for(int i = 0; i < weight.length; i++) { // 遍历物品
            for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
                // 以上为01背包,然后加一个遍历个数
                for (int k = 1; k <= nums[i] && (j - k * weight[i]) >= 0; k++) { // 遍历个数
                    dp[j] = Math.max(dp[j], dp[j - k * weight[i]] + k * value[i]);
                }
                System.out.println(Arrays.toString(dp));
            }
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    背包总结

    动态规划五部曲

    1. 确定dp数组(dp table)以及下标的含义
    2. 确定递推公式
    3. dp数组如何初始化
    4. 确定遍历顺序
    5. 举例推导dp数组

    确定递推公式

    问能否能装满背包(或者最多装多少):dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]); ,对应题目如下:

    动态规划:416.分割等和子集

    动态规划:1049.最后一块石头的重量 II

    问装满背包有几种方法:dp[j] += dp[j - nums[i]] ,对应题目如下:

    动态规划:494.目标和

    动态规划:518. 零钱兑换 II

    动态规划:377.组合总和Ⅳ

    动态规划:70. 爬楼梯进阶版(完全背包)

    问背包装满最大价值:dp[j] = max(dp[j], dp[j - weight[i]] + value[i]); ,对应题目如下:

    动态规划:474.一和零

    问装满背包所有物品的最小个数:dp[j] = min(dp[j - coins[i]] + 1, dp[j]); ,对应题目如下:

    动态规划:322.零钱兑换

    动态规划:279.完全平方数

    确定遍历顺序

    01背包一维数组版:

    先遍历物品,再遍历背包,背包从大到小遍历

    完全背包:

    如果求组合数就是外层for循环遍历物品,内层for遍历背包

    如果求排列数就是外层for遍历背包,内层for循环遍历物品

  • 相关阅读:
    【软考软件评测师】基于规则说明的测试技术下篇
    Java18新特性
    分享五款没什么名气却意外好用的软件
    C++(STL容器适配器)
    基于片段的分子生成网络 (FLAG)使用方法及案例测评
    shiro反序列化漏洞分析
    OpenCV cv::Mat和QImage互相转换
    老狼数码:电视盒子哪个牌子好?目前最强的电视盒子
    工业智能网关如何快对接微软云Azure IOT
    SAP UI5 的规则构建器控件介绍
  • 原文地址:https://blog.csdn.net/xinrenne/article/details/132775955