139 单词划分

思路

看到这道题目的时候，大家应该回想起我们之前讲解回溯法专题的时候，讲过的一道题目 回溯算法：131 分割回文串 ，就是枚举字符串的所有分割情况。枚举分割后的所有子串，判断是否回文。
本道是枚举分割所有字符串，判断是否在字典里出现过。

回溯方法的递归的过程中有很多重复计算，可以使用数组保存一下递归过程中计算的结果。
这个叫做记忆化递归，这种方法我们之前已经提过很多次了。
使用memory数组保存每次计算的以startIndex起始的计算结果，如果memory[startIndex]里已经被赋值了，直接用memory[startIndex]的结果。

详见Java回溯法?
这个代码就可以AC了，当然回溯算法不是本题的主菜，背包才是！

手写分析

动规五部曲分析

单词就是物品，字符串s就是背包，单词能否组成字符串s，就是问物品能不能把背包装满。
拆分时可以重复使用字典中的单词，说明就是一个完全背包！
动规五部曲分析如下：

1. 确定dp数组以及下标的含义

dp[i] ：下标i前是否都可以用字典的单词表示。

2. 确定递推公式

如果确定dp[j] 是true（左边），且 [j, i] 这个区间的子串出现在字典里（右边），那么dp[i]一定是true。（j < i ）。
所以递推公式是** if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true**。

3. dp数组如何初始化

从递推公式中可以看出，dp[i] 的状态依靠 dp[j]是否为true，那么dp[0]就是递推的根基，dp[0]一定要为true，否则递推下去后面都都是false了。
从定义中，dp[0] 在字典中无需使用单词就能表示，因此dp[0] = true。

4. 确定遍历顺序

题目中说是拆分为一个或多个在字典中出现的单词，所以这是完全背包。
还要讨论两层for循环的前后顺序。
如果求组合数就是外层for循环遍历物品，内层for遍历背包。
如果求排列数就是外层for遍历背包，内层for循环遍历物品。
我在这里做一个总结：
求组合数：动态规划：518.零钱兑换II
求排列数：动态规划：377. 组合总和 Ⅳ、动态规划：70. 爬楼梯进阶版（完全背包）
求最小数：动态规划：322. 零钱兑换(opens new window)、动态规划：279.完全平方数

而本题其实我们求的是排列数，为什么呢。 拿 s = “applepenapple”, wordDict = [“apple”, “pen”] 举例。
“apple”, “pen” 是物品，那么我们要求 物品的组合一定是 “apple” + “pen” + “apple” 才能组成 “applepenapple”。
“apple” + “apple” + “pen” 或者 “pen” + “apple” + “apple” 是不可以的，那么我们就是强调物品之间顺序。
所以说，本题一定是 先遍历 背包，再遍历物品。

5. 举例推导dp[i]

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

dp[s.length()]就是最终结果。
动规五部曲分析完毕，代码如下：

public boolean wordBreak(String s, List<String> wordDict) {
    boolean[] dp = new boolean[s.length() + 1];
    HashSet<String> hs = new HashSet<>(wordDict);
    dp[0] = true;
    for (int i = 1; i<= s.length(); i++){
        for (int j = 0; j < i; j++){
            if (dp[j] && hs.contains(s.substring(j,i))){
                dp[i] = true;
            }
        }
    }
    return dp[s.length()];
}
public boolean wordBreak(String s, List<String> wordDict) {
    boolean[] dp = new boolean[s.length() + 1];
    HashSet<String> hs = new HashSet<>(wordDict);
    dp[0] = true;

    for (int i = 1; i<= s.length(); i++){
        for (int j = 0; j < i; j++){
            if (dp[j] && hs.contains(s.substring(j,i))){
                dp[i] = true;
            }
        }
    }

    return dp[s.length()];
}
public boolean wordBreak(String s, List<String> wordDict) {
    boolean[] dp = new boolean[s.length() + 1];
    HashSet<String> hs = new HashSet<>(wordDict);
    dp[0] = true;

    for (int i = 1; i<= s.length(); i++){
        for (int j = 0; j < i; j++){
            if (dp[j] && hs.contains(s.substring(j,i))){
                dp[i] = true;
            }
        }
    }

    return dp[s.length()];
}

• 时间复杂度：O(n^3)，因为substr返回子串的副本是O(n)的复杂度（这里的n是substring的长度）
• 空间复杂度：O(n)

多重背包理论基础

有N种物品和一个容量为V 的背包。N个物品中的第 i 种物品最多有Mi件可用，每件耗费的空间是Ci ，价值是Wi 。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量，且价值总和最大。（多了数量维度上限值）
多重背包和01背包是非常像的， 为什么和01背包像呢？
每件物品最多有Mi件可用，把Mi件摊开，其实就是一个01背包问题了。
例如：
背包最大重量为10。
物品为：

问背包能背的物品最大价值是多少？
和如下情况把物品摊开有区别么？

毫无区别，这就转成了一个01背包问题了，且每个物品只用一次。
这种方式来实现多重背包的代码如下：

public void testMultiPack1(){
    //  补充必要值
    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);
        }
    }
    // 动态规划 - 01背包问题
    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 testMultiPack1(){
    //  补充必要值
    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);
        }
    }

    // 动态规划 - 01背包问题
    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 testMultiPack1(){
    //  补充必要值
    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);
        }
    }

    // 动态规划 - 01背包问题
    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));
    }
}

• 时间复杂度：O(m × n × k)，m：物品种类个数，n背包容量，k单类物品数量

推荐上面?方式，好理解~

也有另一种实现方式，就是把每种商品遍历的个数放在01背包里面在遍历一遍。
代码如下：（详看注释）

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));
        }
    }
}
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));
        }
    }
}
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));
        }
    }
}

• 时间复杂度：O(m × n × k)，m：物品种类个数，n背包容量，k单类物品数量

从代码里可以看出是01背包里面在加一个for循环遍历一个每种商品的数量。 和01背包还是如出一辙的。
当然还有那种二进制优化的方法，其实就是把每种物品的数量，打包成一个个独立的包。
和以上在循环遍历上有所不同，因为是分拆为各个包最后可以组成一个完整背包，具体原理我就不做过多解释了，大家了解一下就行，面试的话基本不会考完这个深度了，感兴趣可以自己深入研究一波。

总结

多重背包在面试中基本不会出现，力扣上也没有对应的题目，大家对多重背包的掌握程度知道它是一种01背包，并能在01背包的基础上写出对应代码就可以了。
（背包问题深度还有混合背包，二维费用背包，分组背包等等感兴趣可查阅资料学习，面试不考~）

学习资料：

139.单词拆分

多重背包理论基础