day21

猿小羽

于 2022-04-07 22:37:28 发布

阅读量331

点赞数

分类专栏： leetcode 文章标签：算法动态规划背包问题完全背包 leetcode

本文链接：https://blog.csdn.net/sj15814963053/article/details/124028715

版权

leetcode 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

day21

474. 一和零

力扣题目链接

题目

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

提示：

1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 '0' 和 '1' 组成
1 <= m, n <= 100

思路

本题中strs 数组里的元素就是物品，每个物品都是一个！

而 m 和 n 相当于是一个背包，两个维度的背包。

本题是01背包问题！

这不过这个背包有两个维度，一个是 m 一个是 n，而不同长度的字符串就是不同大小的待装物品。

确定dp数组（dp table）以及下标的含义

dp[i][j]：最多有 i个0 和 j个1 的 strs 的最大子集的大小为 dp[i][j]。

确定递推公式

dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。

dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。

然后我们在遍历的过程中，取dp[i][j]的最大值。

所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

对比一下就会发现，字符串的 zeroNum 和 oneNum 就相当于是物品的重量（weight[i]），字符串本身的个数就相当于物品的价值（value[i]）。

这就是一个典型的01背包！ 只不过物品的重量有了两个维度而已。

dp数组如何初始化

因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

确定遍历顺序

我们讲到了01背包为什么一定是外层for循环遍历物品，内层for循环遍历背包容量是从后向前遍历！

那么本题也是，物品就是 strs 里的字符串，背包容量就是题目描述中的 m 和 n。

举例推导dp数组

以输入：[“10”,“0001”,“111001”,“1”,“0”]，m = 3，n = 3为例

最后dp数组的状态如下所示：

Untitled

代码实现

/**
 * https://leetcode-cn.com/problems/ones-and-zeroes/
 *
 * @author xiexu
 * @create 2022-04-06 21:41
 */
public class _474_一和零 {

    public int findMaxForm(String[] strs, int m, int n) {
        // dp[i][j] 表示i个0 和 j个1 时的最大子集
        int[][] dp = new int[m + 1][n + 1];
        int oneNum, zeroNum;
        for (String str : strs) {
            oneNum = 0;
            zeroNum = 0;
            for (char ch : str.toCharArray()) {
                if (ch == '0') {
                    zeroNum++;
                } else {
                    oneNum++;
                }
            }
            // 倒序遍历
            for (int i = m; i >= zeroNum; i--) {
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }

}

完全背包理论基础

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。

完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。

在下面的讲解中，我依然举这个例子：

背包最大重量为4。

物品为：

Untitled

每件商品都有无限个！

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

01背包和完全背包唯一不同就是体现在遍历顺序上，所以本文就不去做动规五部曲了，我们直接针对遍历顺序经行分析！

首先再回顾一下01背包的核心代码

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

我们知道01背包内嵌的循环是从大到小遍历，为了保证每个物品仅被添加一次。

而完全背包的物品是可以添加多次的，所以要从小到大去遍历，即：

// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

dp状态图如下：

Untitled

为什么遍历物品在外层循环，遍历背包容量在内层循环 ?

01背包中二维dp数组的两个for遍历的先后循序是可以颠倒了，一维dp数组的两个for循环先后循序一定是先遍历物品，再遍历背包容量。

在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序同样无所谓！

因为dp[j] 是根据下标j之前所对应的dp[j]计算出来的。只要保证下标j之前的dp[j]都是经过计算的就可以了。

遍历物品在外层循环，遍历背包容量在内层循环，状态如图：

Untitled

遍历背包容量在外层循环，遍历物品在内层循环，状态如图：

Untitled

两个for循环的先后循序，都不影响计算dp[j]所需要的值（这个值就是下标j之前所对应的dp[j]）

代码实现

先遍历物品再遍历背包

/**
 * @author xiexu
 * @create 2022-04-06 22:20
 */
public class 完全背包理论基础_先物品再背包 {

    public static void main(String[] args) {
        test_CompletePack();
    }

    public static void test_CompletePack() {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        int bagWeight = 4;
        int[] dp = new int[bagWeight + 1];
        for (int i = 0; i < weight.length; i++) { // 先遍历物品
            for (int j = weight[i]; j <= bagWeight; j++) { // 再遍历背包容量
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
        //打印dp数组
        for (int j = 0; j <= bagWeight; j++) {
            System.out.print(dp[j] + " ");
        }
    }

}

先遍历背包再遍历物品

/**
 * @author xiexu
 * @create 2022-04-06 22:45
 */
public class 完全背包理论基础_先背包再物品 {

    public static void main(String[] args) {
        test_CompletePack();
    }

    public static void test_CompletePack() {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20, 30};
        int bagWeight = 4;
        int[] dp = new int[bagWeight + 1];
        for (int j = 0; j <= bagWeight; j++) { // 先遍历背包容量
            for (int i = 0; i < weight.length; i++) { // 再遍历物品
                if (j - weight[i] >= 0) {
                    dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
                }
            }
        }
        //打印dp数组
        for (int j = 0; j <= bagWeight; j++) {
            System.out.print(dp[j] + " ");
        }
    }

}

518. 零钱兑换 II

力扣题目链接

题目

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

示例 1：

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

示例 2：

输入：amount = 3, coins = [2]
输出：0
解释：只用面额 2 的硬币不能凑成总金额 3 。

示例 3：

输入：amount = 10, coins = [10] 
输出：1

提示：

1 <= coins.length <= 300
1 <= coins[i] <= 5000
coins 中的所有值 互不相同
0 <= amount <= 5000

思路

排列和组合的区别 ?

5 = 2 + 2 + 1

5 = 2 + 1 + 2

这是一种组合，都是 2 2 1。

如果问的是排列数，那么上面就是两种排列了。

组合不强调元素之间的顺序，排列强调元素之间的顺序。

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

dp[j]：凑成总金额j的货币组合数为dp[j]

确定递推公式

dp[j] （考虑coins[i]的组合总和）就是所有的 dp[j - coins[i]]（不考虑coins[i]）相加。

所以递推公式：dp[j] += dp[j - coins[i]];

求装满背包有几种方法，一般公式都是：dp[j] += dp[j - nums[i]];

dp数组如何初始化

首先dp[0]一定要为1，dp[0] = 1是递归公式的基础。

从dp[i]的含义上来讲就是，凑成总金额0的货币组合数为1。

下标非0的dp[j]初始化为0，这样累计加dp[j - coins[i]]的时候才不会影响真正的dp[j]

确定遍历顺序

先遍历物品，再遍历背包

外层for循环遍历物品（钱币），内层for遍历背包（金钱总额）的情况。

for (int i = 0; i < coins.size(); i++) { // 遍历物品
    for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
        dp[j] += dp[j - coins[i]];
    }
}

假设：coins[0] = 1，coins[1] = 5。

那么就是先把1加入计算，然后再把5加入计算，得到的方法数量只有{1, 5}这种情况。而不会出现{5, 1}的情况。

所以这种遍历顺序中dp[j]里计算的是组合数！

先遍历背包再遍历物品

for (int j = 0; j <= amount; j++) { // 遍历背包容量
    for (int i = 0; i < coins.size(); i++) { // 遍历物品
        if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
    }
}

背包容量的每一个值，都是经过 1 和 5 的计算，包含了{1, 5} 和 {5, 1}两种情况。

此时dp[j]里算出来的就是排列数！

举例推导dp数组

输入: amount = 5, coins = [1, 2, 5] ，dp状态图如下：

Untitled

最后红色框dp[amount]为最终结果。

总结

在求装满背包有几种方案的时候，认清遍历顺序是非常关键的。

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

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

代码实现

/**
 * https://leetcode-cn.com/problems/coin-change-2/
 *
 * @author xiexu
 * @create 2022-04-06 22:58
 */
public class _518_零钱兑换_II {

    public int change(int amount, int[] coins) {
        // dp[j]：凑成总金额j的货币组合数为 dp[j]
        int[] dp = new int[amount + 1];
        // 初始化dp数组，表示金额为0时只有一种情况，也就是什么都不装
        dp[0] = 1;
        for (int i = 0; i < coins.length; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }

}

377. 组合总和 Ⅳ

力扣题目链接

题目

给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

示例 1：

输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。

示例 2：

输入：nums = [9], target = 3
输出：0

提示：

1 <= nums.length <= 200
1 <= nums[i] <= 1000
nums 中的所有元素 互不相同
1 <= target <= 1000

思路

弄清什么是组合，什么是排列很重要。

组合不强调顺序，(1,5)和(5,1)是同一个组合。

排列强调顺序，(1,5)和(5,1)是两个不同的排列。

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

dp[j]: 凑成目标正整数为 j 的排列个数为 dp[j]

确定递推公式

dp[j]（考虑nums[i]）可以由 dp[j - nums[i]]（不考虑nums[i]）推导出来。

因为只要得到 nums[i]，排列个数dp[j - nums[i]]，就是dp[j]的一部分。

dp数组如何初始化

因为递推公式 dp[j] += dp[j - nums[i]] 的缘故，dp[0]要初始化为1，这样递归其他dp[j]的时候才会有数值基础。

非0下标的dp[j]初始化为0，这样才不会影响dp[j]累加所有的 dp[j - nums[i]]。

确定遍历顺序

个数可以不限使用，说明这是一个完全背包。

得到的集合是排列，说明需要考虑元素之间的顺序。

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

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

如果把遍历nums（物品）放在外循环，遍历target的作为内循环的话，举一个例子：计算dp[4]的时候，结果集只有 {1,3} 这样的集合，不会有{3,1}这样的集合，因为nums遍历放在外层，3只能出现在1后面！

所以本题遍历顺序最终遍历顺序：target（背包）放在外循环，将nums（物品）放在内循环，内循环从前到后遍历。

举例来推导dp数组

Untitled

代码实现

/**
 * https://leetcode-cn.com/problems/combination-sum-iv/
 *
 * @author xiexu
 * @create 2022-04-07 00:03
 */
public class _377_组合总和_Ⅳ {

    public int combinationSum4(int[] nums, int target) {
        // dp[j]: 凑成目标正整数为j的排列个数为dp[j]
        int[] dp = new int[target + 1];
        dp[0] = 1;
        for (int j = 0; j <= target; j++) { // 先遍历背包
            for (int i = 0; i < nums.length; i++) { // 再遍历物品
                if (j >= nums[i]) {
                    dp[j] += dp[j - nums[i]];
                }
            }
        }
        return dp[target];
    }

}

70. 爬楼梯 (进阶版)

力扣题目链接

题目

一步一个台阶，两个台阶，三个台阶，…，直到 m个台阶。问有多少种不同的方法可以爬到楼顶呢 ?

1阶，2阶，… m阶就是物品，楼顶就是背包。

每一阶可以重复使用，例如跳了1阶，还可以继续跳1阶。

问跳到楼顶有几种方法其实就是问装满背包有几种方法。

思路

可以发现这道进阶版的题目是完全背包问题

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

dp[j]：爬到有j个台阶的楼顶，有dp[j]种方法

确定递推公式

求装满背包有几种方法，递推公式一般都是 dp[j] += dp[j - nums[i]];

本题呢，dp[j]有几种来源，dp[j - 1]，dp[j - 2]，dp[j - 3] 等等，即：dp[j - i]

那么递推公式为：dp[j] += dp[j - i]

dp数组如何初始化

既然递归公式是 dp[j] += dp[j - i]，那么dp[0] 一定为1，dp[0]是递归中一切数值的基础所在，如果 dp[0] 是 0 的话，其他数值都是0了。

下标非0的dp[j]初始化为0，因为 dp[j] 是靠 dp[j-i] 累计上来的，dp[j] 本身为0这样才不会影响结果

确定遍历顺序

这是背包里求排列问题，即：1、2 步和 2、1 步都是上三个台阶，但是这两种方法不一样！

所以需将target放在外循环，将nums放在内循环。

每一步可以走多次，这是完全背包，内循环需要从前向后遍历。

举例来推导dp数组

代码实现

/**
 * https://leetcode-cn.com/problems/climbing-stairs/
 *
 * @author xiexu
 * @create 2022-04-07 21:00
 */
public class _70_爬楼梯 {

    public int climbStairs(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 1;
        for (int j = 1; j <= n; j++) {
						// m表示最多可以爬m个台阶，代码中把m改成2就是本题70.爬楼梯可以AC的代码了
            for (int i = 1; i <= m; i++) {
                if (j >= i) {
                    dp[j] += dp[j - i];
                }
            }
        }
        return dp[n];
    }

}

322. 零钱兑换

力扣题目链接

题目

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1

示例 2：

输入：coins = [2], amount = 3
输出：-1

示例 3：

输入：coins = [1], amount = 0
输出：0

提示：

1 <= coins.length <= 12
1 <= coins[i] <= 2^31 - 1
0 <= amount <= 10^4

思路

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

dp[j]：凑足总额为j所需钱币的最少个数为dp[j]

确定递推公式

得到dp[j]（考虑coins[i]），只有一个来源，dp[j - coins[i]]（没有考虑coins[i]）。

凑足总额为 j - coins[i] 的最少个数为 dp[j - coins[i]]，那么只需要加上一个钱币coins[i] 即 dp[j - coins[i]] + 1 就是 dp[j]（考虑coins[i]）

所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。

递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);

dp数组如何初始化

首先凑足总金额为0所需钱币的个数一定是0，那么dp[0] = 0;

其他下标对应的数值呢？

考虑到递推公式的特性，dp[j] 必须初始化为一个最大的数，否则就会在 min(dp[j - coins[i]] + 1, dp[j]) 比较的过程中会被初始值覆盖。

所以下标非0的元素都是应该是最大值。

确定遍历顺序

本题求钱币最小个数，那么钱币有顺序和没有顺序都可以，都不影响钱币的最小个数。

所以本题并不强调集合是组合还是排列。

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

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

所以本题的两个for循环的关系是：外层for循环遍历物品，内层for遍历背包或者外层for遍历背包，内层for循环遍历物品都是可以的！

那么我采用coins放在外循环，target在内循环的方式。

本题钱币数量可以无限使用，那么是完全背包。所以遍历的内循环是正序

综上所述，遍历顺序为：coins（物品）放在外循环，target（背包）在内循环。且内循环正序。

举例推导dp数组

以输入：coins = [1, 2, 5], amount = 5为例

Untitled

dp[amount] 为最终结果。

代码实现

先遍历物品再遍历背包

/**
 * https://leetcode-cn.com/problems/coin-change/
 *
 * @author xiexu
 * @create 2022-04-07 21:22
 */
public class _322_零钱兑换 {

    public int coinChange(int[] coins, int amount) {
        int max = Integer.MAX_VALUE;
        // dp[j]：凑足总额为j所需钱币的最少个数为dp[j]
        int[] dp = new int[amount + 1];
        // 给dp数组所有数加上最大值
        Arrays.fill(dp, max);
        // 当金额为0时需要的硬币数目为0
        dp[0] = 0;
        for (int i = 0; i < coins.length; i++) { // 遍历物品
            for (int j = coins[i]; j <= amount; j++) { // 遍历背包
                // 如果dp[j - coins[i]]是初始值则跳过
                if (dp[j - coins[i]] != max) {
                    // 选择硬币数目最小的情况
                    dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
                }
            }
        }
        return dp[amount] == max ? -1 : dp[amount];
    }

}

先遍历背包再遍历物品

/**
 * https://leetcode-cn.com/problems/coin-change/
 *
 * @author xiexu
 * @create 2022-04-07 21:22
 */
public class _322_零钱兑换_先背包再物品 {

    public int coinChange(int[] coins, int amount) {
        int max = Integer.MAX_VALUE;
        // dp[j]：凑足总额为j所需钱币的最少个数为dp[j]
        int[] dp = new int[amount + 1];
        // 给dp数组所有数加上最大值
        Arrays.fill(dp, max);
        // 当金额为0时需要的硬币数目为0
        dp[0] = 0;
        for (int j = 1; j <= amount; j++) { // 先遍历背包
            for (int i = 0; i < coins.length; i++) { // 再遍历物品
                if (j - coins[i] >= 0 && dp[j - coins[i]] != max) {
                    dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
                }
            }
        }
        return dp[amount] == max ? -1 : dp[amount];
    }

}

279. 完全平方数

力扣题目链接

题目

给你一个整数 n ，返回和为 n 的完全平方数的最少数量。

完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

示例 1：

输入：n = 12
输出：3 
解释：12 = 4 + 4 + 4

示例 2：

输入：n = 13
输出：2
解释：13 = 4 + 9

提示：

1 <= n <= 10^4

思路

把题目翻译一下：完全平方数就是物品（可以无限件使用），凑个正整数n就是背包，问凑满这个背包最少有多少物品 ?

确定dp数组（dp table）以及下标的含义

dp[j]：和为j的完全平方数的最少数量为dp[j]

确定递推公式

dp[j] 可以由 dp[j - i * i] 推出， dp[j - i * i] + 1 便可以凑成 dp[j]。

此时我们要选择最小的dp[j]，所以递推公式：dp[j] = min(dp[j - i * i] + 1, dp[j]);

dp数组如何初始化

dp[0]表示和为0的完全平方数的最小数量，那么dp[0]一定是0。

有同学问题，那0 * 0 也算是一种啊，为啥dp[0] 就是 0呢？

看题目描述，找到若干个完全平方数（比如 1, 4, 9, 16, …），题目描述中可没说要从0开始，dp[0]=0完全是为了递推公式。

非0下标的dp[j]应该是多少呢？

从递归公式 dp[j] = min(dp[j - i * i] + 1, dp[j]); 中可以看出每次 dp[j] 都要选最小的，所以非0下标的dp[j]一定要初始为最大值，这样dp[j]在递推的时候才不会被初始值覆盖。

确定遍历顺序

本题是求最小数

所以本题外层for遍历背包，内层for遍历物品，还是外层for遍历物品，内层for遍历背包，都是可以的！

举例推导dp数组

以输入n为5例，dp状态图如下：

Untitled

最后的dp[n]为最终结果。

代码实现

先遍历物品再遍历背包

/**
 * https://leetcode-cn.com/problems/perfect-squares/
 *
 * @author xiexu
 * @create 2022-04-07 22:05
 */
public class _279_完全平方数 {

    public int numSquares(int n) {
        int max = Integer.MAX_VALUE;
        int[] dp = new int[n + 1];
        // 初始化
        Arrays.fill(dp, max);
        // 当和为0时，组合的个数为0
        dp[0] = 0;
        for (int i = 1; i * i <= n; i++) { // 先遍历物品
            for (int j = i * i; j <= n; j++) { // 再遍历背包
                if (dp[j - i * i] != max) {
                    dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
                }
            }
        }
        return dp[n];
    }

}

先遍历背包再遍历物品

/**
 * https://leetcode-cn.com/problems/perfect-squares/
 *
 * @author xiexu
 * @create 2022-04-07 22:05
 */
public class _279_完全平方数_先背包再物品 {

    public int numSquares(int n) {
        int max = Integer.MAX_VALUE;
        int[] dp = new int[n + 1];
        // 初始化
        Arrays.fill(dp, max);
        // 当和为0时，组合的个数为0
        dp[0] = 0;
        for (int j = 1; j <= n; j++) { // 先遍历背包
            for (int i = 1; i * i <= n; i++) { // 再遍历物品
                if (j - i * i >= 0 && dp[j - i * i] != max) {
                    dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
                }
            }
        }
        return dp[n];
    }

}

猿小羽

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
day21

day21474. 一和零力扣题目链接题目给你一个二进制字符串数组 strs 和两个整数 m 和 n 。请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。示例 1：输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3输出：4解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001"
复制链接

扫一扫