面试高频手撕算法 - 背包问题2

最新推荐文章于 2024-06-06 10:51:59 发布
最新推荐文章于 2024-06-06 10:51:59 发布
阅读量263 收藏
点赞数
分类专栏： LeetCode 文章标签： 面试 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xaiobit_hl/article/details/133591843
版权

目录

1. 完全背包

1.1 【模板】完全背包

1.2 零钱兑换

1.3 零钱兑换 II

1.4 完全平方数

2. 二维费用的背包问题

2.1 一和零

2.2 盈利计划

 --- 如果背包问题原先没有基础的，建议先看上一篇博客 --- 面试高频手撕算法 - 01背包系列

1. 完全背包

1.1 【模板】完全背包

【题目链接】

【模板】完全背包_牛客题霸_牛客网你有一个背包，最多能容纳的体积是V。 现在有n种物品，每种物品有任意多个，第。题目来自【牛客题霸】icon-default.png?t=N7T8https://www.nowcoder.com/practice/237ae40ea1e84d8980c1d5666d1c53bc?tpId=230&&tqId=38965&sourceUrl=https%3A%2F%2Fwww.nowcoder.com%2Fexam%2Foj【题目描述】

你有一个背包，最多能容纳的体积是V。
现在有 n 种物品，每种物品有任意多个，第 i 种物品的体积为 vi，价值为 wi。

（1）求这个背包至多能装多大价值的物品？
（2）若背包恰好装满，求至多能装多大价值的物品？

第一问：【算法原理】

再做动态规划系列问题的时候，无非就是这几大步骤：

① 状态定义

② 推导状态转移方程

③ 初始化 dp 表

④ 填表顺序

⑤

返回值

1. 状态定义

背包问题本质上还是一个线性 dp, 所以状态的定义根据线性 dp 的经验: 

状态定义: dp[i] 表示从前 i 个物品中挑选, 所有选法, 能挑选出来的最大价值  (试错)

但是这样定义状态之后, 发现推不出来, 因为不知道体积, 所以需要定义一个二维的 dp.

状态定义:dp[i][j]表示从前 i 个物品中挑选,总体积不超过 j,所有选法中,能挑选出来的最大价值

2. 推导状态转移方程 

根据最后一个位置的状况, 分情况讨论:

        像这种，当我们要表示一个状态的时候，发现它需要很多个状态拼接而成的时候，这个时候我们需要想一个策略，将这些状态用一个或两个等有限个状态来表示。

【数学思想】

        数学里面有种思想是错位相减，此处的做法有点类似，通过给 dp[i][j] 的列上减去一个体积，得到另一个表达式，然后寻找两个表达式之间的关联关系：

于是，我们的状态转移方程就转换成了：dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - v[i]] + w[i])

3. 初始化 dp 表

为了方便代码进行 dp 的一个过程, 我们都会根据情况给 dp 表多加一行, 一列.

由于使用到前面的列的时候, 会进行判断, 所以初始化的时候, 可以不用初始化列, 只需要初始化行.

当只有 0 个商品的时候，想要体积不超过 0，1，2，3..... 最大价值肯定都是 0 了.

4. 填表顺序

从状态转移方程来分析，dp[i] 会使用到上一行，以及当前行前面的列， 所以填表顺序从上往下，从左往右填.

5. 返回值

从状态表示：从前 i 个物品中挑选，总体积不超过 j 的最大价值， 再结合题目要求，

得出最终的状态：从前 n 个物品中挑选，总体积不超过 V 的最大价值，所以返回 dp[n][V] 即可.

第一问：【编写关键代码】

/**
 * (1)求这个背包至多能装多大价值的物品？
 * @param v 每个商品所对应的体积
 * @param w 每个商品所对应的价值
 * @param V 背包体积
 * @param n 商品数量
 * @return
 */
public int getMaxVlaue(int[] v, int[] w, int V, int n) {
    int[][] dp = new int[n + 1][V + 1];
    // 从前 i 个商品中挑选,总体积不超过 j,最大价值是多少
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= V; ++j) {
            // 不挑选 i 商品
            dp[i][j] = dp[i - 1][j];
            // 挑选 i 商品, 数学思想简化状态转移方程
            if(j - v[i] >= 0) {
                dp[i][j] = Math.max(dp[i][j],dp[i][j - v[i]] + w[i]);
            }
        }
    }
    return dp[n][V];
}

此处先理解最基础的代码，等看完第二问， 再统一做空间优化.

第二问：【算法原理】

1. 状态定义

有了前面的经验，接下来就直接定义状态了.

状态定义:dp[i][j]表示从前 i 个物品中挑选,总体积正好为 j,所有选法中,能挑选出来的最大价值

2. 推导状态转移方程

此处的状态转移方程和第一问几乎一模一样， 只需要处理一些细节：

根据上面的数学推导，得出的状态转移方程：dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - v[i] + w[i]])

        但是此处需要正好装满，所以 j - v[i] 就有可能不存在，所以需要像 01 背包那样，给第一行除第一个位置，全部设为 -1 或者 -0x3f3f3f3f，因为没有商品的时候，不可能凑出体积为 1，2，3 的情况.

4. 填表顺序

从上往下，从左往右

5.返回值

dp[n][V]

第二问：【编写关键代码】

/**
 * (2)若背包恰好装满，求至多能装多大价值的物品？
 * @param v 每个商品所对应的体积
 * @param w 每个商品所对应的价值
 * @param V 背包体积
 * @param n 商品数量
 * @return
 */
public static int getMaxVlaue(int[] v, int[] w, int V, int n) {
    int[][] dp = new int[n + 1][V + 1];
    // 状态定义：从前 i 个商品中挑选,体积恰好等于 j,最大价值为多少

    // 体积不能正好等于 j 的,统统初始化为 -0x3f3f3f3f
    for(int j = 1; j <= V; ++j) dp[0][j] = -0x3f3f3f3f;

    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= V; ++j) {
            // 不选 i
            dp[i][j] = dp[i - 1][j];
            // 选 i，-0x3f3f3f3f 不需要做条件判断，因为它足够小，取 max 不影响
            if(j - v[i] >= 0) {
                dp[i][j] = Math.max(dp[i][j],dp[i][j - v[i]] + w[i]);
            }
        }
    }
    return dp[n][V] < 0 ? 0 : dp[n][V];
}

 【空间优化】

  • 利用滚动数组做空间上的优化
  • 直接在原始代码上稍加修改即可

        利用滚动数组优化的时候，需要注意内层循环的填表顺序，由于 dp[i][j] 只会用到上一行的当前列，以及当前行前面的列，所以内层循环填表和 01 背包不一样，完全背包空间优化后，内层循环需要从左往右填表.

第一问：空间优化后的代码

/**
 * (1)求这个背包至多能装多大价值的物品？
 * @param v 每个商品所对应的体积
 * @param w 每个商品所对应的价值
 * @param V 背包体积
 * @param n 商品数量
 * @return
 */
public int getMaxVlaue(int[] v, int[] w, int V, int n) {
    int[] dp = new int[V + 1];
    // 从前 i 个商品中挑选,总体积不超过 j,最大价值是多少
    for(int i = 1; i <= n; ++i) {
        for(int j = v[i]; j <= V; ++j) {
            dp[j] = Math.max(dp[j],dp[j - v[i]] + w[i]);
        }
    }
    return dp[V];
}

第二问：空间优化后的代码

/**
 * (2)若背包恰好装满，求至多能装多大价值的物品？
 * @param v 每个商品所对应的体积
 * @param w 每个商品所对应的价值
 * @param V 背包体积
 * @param n 商品数量
 * @return
 */
public static int getMaxVlaue(int[] v, int[] w, int V, int n) {
    int[] dp = new int[V + 1];
    // 状态定义：从前 i 个商品中挑选,体积恰好等于 j,最大价值为多少

    // 体积不能正好凑成 j 的,统统初始化为 -0x3f3f3f3f
    for(int j = 1; j <= V; ++j) dp[j] = -0x3f3f3f3f;

    for(int i = 1; i <= n; ++i) {
        for(int j = v[i]; j <= V; ++j) {
            dp[j] = Math.max(dp[j],dp[j - v[i]] + w[i]);
        }
    }
    return dp[V] < 0 ? 0 : dp[V];
}

       有了这两道完全背包的基础之后，后面的完全包相关的题目，可以先自己尝试去做，在看答案之前，自己能做出来，记忆还是非常深刻的.

1.2 零钱兑换

【题目链接】

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/coin-change/【题目描述】

给你一个整数数组 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. 状态定义

        模仿完全背包的状态定义：dp[i][j] 表示：从前 i 个物品中挑选，总体积不超过 j，所有选法中，最大价值.

状态定义：dp[i][i] 表示从前 i 个硬币中挑选，总和正好等于 j，所有的选法中，最少的硬币个数

2. 推导状态转移方程

根据最后一个位置的状况, 分情况讨论:

        有了上题的经验，当出现这种定义一个状态需要无线个状态来拼接的时候，这个时候我们要想办法把它变成一个或两个状态.

大家可以自己动手写写递推关系，找到 dp[i][j] 与 dp[i][j - coins[i]] 的关系，得到最终的状态转移方程：dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - coins[i] + 1])

3. 编写代码

/**
 * 零钱兑换 - 完全背包
 * @param coins 硬币数组
 * @param amount 目标值
 * @return
 */
public int coinChange(int[] coins, int amount) {
    int n = coins.length;
    int INF = 0x3f3f3f3f;
    int[][] dp = new int[n + 1][amount + 1];
    // 状态定义：dp[i][i] 表示从前i个硬币中挑选,总和正好等于j,所有的选法中,最少硬币个数

    // 不难正好凑成 j 元
    for(int j = 1; j <= amount; ++j) dp[0][j] = INF;

    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j <= amount; ++j) {
            // 不选 i
            dp[i][j] = dp[i - 1][j];
            // 选 i, 具体选几个 i,用数学方法优化
            if(j >= coins[i - 1]) {
                dp[i][j] = Math.min(dp[i][j], dp[i][j - coins[i - 1]] + 1);
            }
        }
    }
    // 可能不存在正好凑出的情况
    return dp[n][amount] >= INF ? -1 : dp[n][amount];
}

4. 空间优化

  1. 删掉一维
  2. 内层循环从左往右
/**
 * 零钱兑换 - 完全背包
 * @param coins 硬币数组
 * @param amount 目标值
 * @return
 */
public int coinChange(int[] coins, int amount) {
    int n = coins.length;
    int INF = 0x3f3f3f3f;
    int[] dp = new int[amount + 1];
    // 状态定义：dp[i][i] 表示从前i个硬币中挑选,总和正好等于j,所有的选法中,最少硬币个数

    // 不能正好凑成 j 元
    for(int j = 1; j <= amount; ++j) dp[j] = INF;

    for(int i = 1; i <= n; ++i) {
        for(int j = coins[i - 1]; j <= amount; ++j) {
            dp[j] = Math.min(dp[j], dp[j - coins[i - 1]] + 1);
        }
    }
    // 可能不存在正好凑出的情况
    return dp[amount] >= INF ? -1 : dp[amount];
}

1.3 零钱兑换 II

【题目链接】

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/coin-change-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

【算法原理】

        零钱兑换 II 其实比零钱兑换还简单，此处求的是凑成 j 元的方法数，只要不是求最大价值或最小价值中的正好凑成某某某，初始化工作就很简单.

1.定义状态

状态定义：dp[i][i] 表示从前 i 个硬币中挑选，总和正好等于 j，总共有多少种选法

2. 推导状态转移方程

有前面的基础了，数学思想直接得出状态转移方程： dp[i][j] = dp[i - 1][j] + dp[i][j- coins[i]]

        此处需要注意的是，第二个状体千万不能在后面 + 1，因为求得是选法，以 i 结尾，是把最后一个位置拼在前面的选法中，所以本质上是同一种选法，求个数才需要 + 1，可以好好体会为什么是这样.

3. 编写代码 

/**
 * 零钱兑换 II - 完全背包
 * @param coins 硬币数组
 * @param amount 目标值
 * @return
 */
public int change(int amount, int[] coins) {
    int n = coins.length;
    int[][] dp = new int[n + 1][amount + 1];
    // 状态定义：dp[i][i] 表示从前 i 个硬币中挑选，总和正好等于 j，总共有多少种选法

    dp[0][0] = 1; // 初始化

    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j <= amount; ++j) {
            // 不选 i
            dp[i][j] = dp[i - 1][j];
            if(j >= coins[i - 1]) {
                // 选 i， 数学思想优化状态转移方程
                dp[i][j] += dp[i][j - coins[i - 1]];
            }
        }
    }
    return dp[n][amount];
}

4. 空间优化

  1. 删掉一维
  2. 内层循环从左往右
/**
 * 零钱兑换 II - 完全背包
 * @param coins 硬币数组
 * @param amount 目标值
 * @return
 */
public int change(int amount, int[] coins) {
    int n = coins.length;
    int[] dp = new int[amount + 1];
    // 状态定义：dp[i][i] 表示从前 i 个硬币中挑选，总和正好等于 j，总共有多少种选法

    dp[0] = 1; // 初始化

    for(int i = 1; i <= n; ++i) {
        for(int j = coins[i - 1]; j <= amount; ++j) {
            dp[j] += dp[j - coins[i - 1]];
        }
    }
    return dp[amount];
}

1.4 完全平方数

【题目链接】

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/perfect-squares/【题目描述】

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

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

示例 1：

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

示例 2：

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

【算法原理】

        这道题如果想到的是贪心，那么就想错了，对于 13，贪心做法先找 9，再找 4，看似没问题，但是如果是 12，贪心做法先找 9， 再找三个 1，这样就需要 4 个完全平方数了，而三个 4 只需要 3 个完全平方数. 

所以我们干脆就从第一个开始往后挑，那么就是这样理解：从前 i 个完全平方数中挑选几个数，正好凑成 j，所有的选法中，使用最少的完全平方数.

这正好就是完全背包问题！

1.状态定义

状态定义：从前 i 个完全平方数中挑选，总和正好等于 j，所有的选法中，最小的数量

2. 推到状态转移方程

 使用数学思想得出最终的状态转移方程：dp[i][j] = Math.min(dp[i - 1][j]，dp[i][j - i * i] + 1)

3. 编写代码

/**
 * 完全平方数
 * @param n 目标值
 * @return
 */
public int numSquares(int n) {
    int INF = 0x3f3f3f3f;
    // i^2 <= n
    int m = (int)Math.sqrt(n);
    int[][] dp = new int[m + 1][n + 1];
    // 状态定义：从前 i 个完全平方数中挑选，总和正好等于 j，所有的选法中，最小的数量
    for(int j = 1; j <= n; ++j) dp[0][j] = INF; // 不能正好凑成 j

    for(int i = 1; i <= m; ++i) {
        for(int j = 1; j <= n; ++j) {
            // 不选 i ^ 2
            dp[i][j] = dp[i - 1][j];
            if(j >= i * i) {
                // 选 i ^ 2
                dp[i][j] = Math.min(dp[i][j],dp[i][j - i * i]  + 1);
            }
        }
    }
    return dp[m][n] >= INF ? 0 : dp[m][n];
}

        此处二维 dp 表的横坐标，最多用到 1 ~ 根号 n，因为 13 只会用到 1，4，9，不可能用到 16，所以可以得出 i ^ 2 <= n。

4. 空间优化

/**
 * 完全平方数
 * @param n 目标值
 * @return
 */
public int numSquares(int n) {
    int INF = 0x3f3f3f3f;
    int m = (int)Math.sqrt(n);
    int[] dp = new int[n + 1];
    // 状态定义：从前 i 个完全平方数中挑选，总和正好等于 j，所有的选法中，最小的数量
    for(int j = 1; j <= n; ++j) dp[j] = INF; // 不能正好凑成 j

    for(int i = 1; i <= m; ++i) {
        for(int j = i * i; j <= n; ++j) {
            dp[j] = Math.min(dp[j],dp[j - i * i]  + 1);
        }
    }
    return dp[n] >= INF ? 0 : dp[n];
}

2. 二维费用的背包问题

        什么是二维费用的背包问题呢，简单来说就是有两个限定条件的背包问题，接下来结合题目来理解二维费用的背包问题.

2.1 一和零

【题目链接】

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/ones-and-zeroes/【题目描述】

给你一个二进制字符串数组 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 。

题目意思：从前 i 个字符串中挑选，个数上满足 0 <= 5 && 1 <= n，所有选法中的最大子集.

【算法原理】

这题本质上就是二维费用的 01 背包，只不过比 01 背包多一维，做法大致相同.

1.状态定义

状态定义：dp[i][j][k] 表示从前 i 个字符串中挑选，字符 0 的个数不超过 j
         字符 1 的个数不超过 k，所有选法中，最大的长度.

2. 推导状态转移方程

最终的状态转移方程： dp[i][j][k] = Math.max(dp[i - 1][j][k]，dp[i - 1][j - a][k - b] + 1)

3. 初始化

当没有字符串的时候，最大子集长度当然就是 0 了，所以不需要初始化.

4. 编写代码

/**
 * 一和零 - 二位费用的 01 背包
 * @param strs
 * @param m
 * @param n
 * @return
 */
public int findMaxForm(String[] strs, int m, int n) {
    int L = strs.length;
    int[][][] dp = new int[L + 1][m + 1][n + 1];
    // 从数组中前 i 个字符串中挑选,0的个数不超过 m,
    // 1的个数不超过 n 的所有子集中,长度最大的子集

    for(int i = 1; i <= L; ++i) {
        // 计算当前字符串  0,1 的个数
        int a = 0, b = 0;
        for(char ch : strs[i - 1].toCharArray()) {
            if(ch == '0') a++;
            else b++;
        }
        for(int j  = 0; j <= m; ++j) {
            for(int k = 0; k <= n; ++k) {
                // 不选 i
                dp[i][j][k] = dp[i -1][j][k];
                // 选 i
                if(j >= a && k >= b) {
                    dp[i][j][k] = Math.max(dp[i][j][k], 
                            dp[i - 1][j - a][k - b] + 1);
                }
            }
        }
    }
    return dp[L][m][n];
}

5. 空间优化

/**
 * 一和零 - 二位费用的 01 背包
 * @param strs
 * @param m
 * @param n
 * @return
 */
public int findMaxForm(String[] strs, int m, int n) {
    int L = strs.length;
    int[][] dp = new int[m + 1][n + 1];
    // 状态定义：从数组中前 i 个字符串中挑选, 0 的个数不超过 m, 
    // 1 的个数不超过 n 的所有子集中, 长度最大的子集
    for(int i = 1; i <= L; ++i) {
        // 计算当前字符串  0,1 的个数
        int a = 0, b = 0;
        for(char ch : strs[i - 1].toCharArray()) {
            if(ch == '0') a++;
            else b++;
        }
        for(int j = m; j >= a; --j) {
            for(int k = n; k >= b; --k) {
                dp[j][k] = Math.max(dp[j][k], dp[j - a][k - b] + 1);
            }
        }
    }
    return dp[m][n];
}

2.2 盈利计划

【题目链接】

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/profitable-schemes/【题目描述】

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。

第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。
如果成员参与了其中一项工作，就不能参与另一项工作。

工作的任何至少产生 minProfit 利润的子集称为盈利计划 。并且工作的成员总数最多为 n 。

有多少种计划可以选择？因为答案很大，所以返回结果模 10^9 + 7 的值。

示例 1：

输入：n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出：2
解释：至少产生 3 的利润，该集团可以完成工作 0 和工作 1 ，或仅完成工作 1 。
总的来说，有两种计划。

示例 2：

输入：n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出：7
解释：至少产生 5 的利润，只要完成其中一种工作就行，所以该集团可以完成任何工作。
有 7 种可能的计划：(0)，(1)，(2)，(0,1)，(0,2)，(1,2)，以及 (0,1,2) 。

题目的意思如下：

 【算法原理】

        这道题与 "一和零" 唯一的区别就是：此处有一个限定条件是满足 >= 某个值，等会需要注意状态转移方程上的差异.

1. 状态定义

状态定义：dp[i][j][k] 表示从前 i 个计划中挑选，总人数不超过 j，
总利润至少为 k，一共有多少种选法

2. 推导状态转移方程

        此处为什么 k - profit[i] 可以 <0 ？ 因为题目要求的就是利润至少 >= x，如果 profit[i] 已经 > x，那不是更好，并且前面的挑选，我只需要保证利润 >= 0 就可以了.

所以对于选 i 的这种情况，状态转移方程是需要稍做处理的，因为像 dp[i][j][-3] 这种状态是没有意义的，所以使它利润为 0 即可，也就是 dp[i - 1][j - group[i]][max(0, k - profit(i))]

所以最终的状态转移方程 : dp[i][j][k] = dp[i - 1][j] + dp[i - 1][j - group[i]][max(0, k - profit(i))]

3. 编写代码

/**
 * 盈利计划 - 二维费用的背包问题
 * @param n 员工数量
 * @param minProfit 至少产生 minProfit 利润
 * @param group 员工数组
 * @param profit 工作所对应的利润数组
 * @return
 */
public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
    int mod = (int)1e9 + 7;
    int L = group.length;
    int m = minProfit;
    int[][][] dp = new int[L + 1][n + 1][m + 1];
    // 初始化: 任务0, 利润0, 人数 0 <= j <= n, 都有一种选法，所以初始化为 1
    for(int j = 0; j <= n; ++j) dp[0][j][0] = 1;

    // 状态：从前 i 个任务中挑选, 人数不超过 j, 利润至少为 k 的选法种数
    for(int i = 1; i <= L; ++i) {
        for(int j = 0; j <= n; ++j) {
            for(int k = 0; k <= m; ++k) {
                // 不选 i
                dp[i][j][k] = dp[i - 1][j][k];
                // 选 i, j - g[i] 必须要 >= 0, 而 k - p[i] 可以小于 0
                if(j >= group[i - 1]) {
                    dp[i][j][k] += dp[i - 1][j - group[i - 1]][Math.max(0, k - profit[i - 1])];
                }
                // 每次让他模上 mod
                dp[i][j][k] %= mod;
            }
        }
    }
    return dp[L][n][m];
}

4. 空间优化

/**
 * 盈利计划 - 二维费用的背包问题
 * @param n 员工数量
 * @param minProfit 至少产生 minProfit 利润
 * @param group 员工数组
 * @param profit 工作所对应的利润数组
 * @return
 */
public int profitableSchemes(int n, int minProfit, int[] group, int[] profit){
    int mod = (int)1e9 + 7;
    int L = group.length;
    int m = minProfit;
    int[][] dp = new int[n + 1][m + 1];
    // 初始化: 任务0, 利润0, 人数不超过 j，0 <= j <= n, 都有一种选法，所以初始化为 1
    for(int j = 0; j <= n; ++j) dp[j][0] = 1;

    // 状态：从前 i 个任务中挑选, 人数不超过 j, 利润至少为 k 的选法种数
    for(int i = 1; i <= L; ++i) {
        for(int j = n; j >= group[i - 1]; --j) {
            for(int k = m; k >= 0; --k) {
                dp[j][k] +=
                        dp[j - group[i - 1]][Math.max(0, k - profit[i - 1])];
                dp[j][k] %= mod;
            }
        }
    }
    return dp[n][m];
}

【总结 看完背包问题的这两篇文章，之后遇到类似的题目，也能有感觉往背包方面去靠，另外就是要理解背包问题的核心：它是用来解决有限制条件下的 " 组合 " 问题！而有些问题看似也是从一堆物品中挑选，并要求满足某个条件，实则并不是背包问题的，例如这道题：组合总和 IV

        像这种 1，2，1 和 1，1，2 算两种选法的，就不是背包问题，因为这种在数学上称之为排列，而背包问题解决的是组合问题. 

背包系列讲解到这就结束了，希望能帮助大家.

Master_hl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
背包问题秒懂-附牛客网真题实战
weixin_64067830的博客
07-15 5万+
一文搞懂背包问题，快来看看吧！
谈谈牛客网-背包问题，解法以及测试用例有错误的实锤
qq_15275521的博客
08-12 869
首先上题目 王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子： 主件 附件 电脑 打印机，扫描仪 书柜 图书 书桌 台灯，文具 工作椅 无 如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第
面试高频手撕算法 - 背包问题1
xaiobit_hl的博客
10-05 1166
面试高频手撕算法 - 01背包
现在Java程序员面试都这么重视手撕算法的能力吗？
javaAnPou的博客
02-22 510
之前逛脉脉，看到这样一条消息确实，前两年，主要是国外大厂比较注重数据结构与算法的考察。但最近这两年，国内的互联网公司，不论大、小厂都紧跟潮流，不管三七二十一，上来先考几道算法题，而且，有必要吗？真的很有必要首先，面试官通过考察候选人算法的能力来判定其、是否能快速掌握新技术的核心要领等等。其次，说得直白、实际些——首先，，尤其像阿里、腾讯、字节这种互联网技术顶尖的公司，面试官在考察候选人时会毫不犹豫地甩给你一道算法题，要求你当场手写，能否进入下一轮或者拿到Offer，在算法面试中可见一斑。
干货！高频手撕算法合集来了
AI科技大本营
10-01 3190
作者 |L的存在来源 |我是程序员小贱(ID:Lanj1995Q)基础数据结构的融合是成为庞大系统的基石。比如Redis中的跳跃表，数据库索引B+树等，只有对基础的数据结构足够的熟悉...
手撕算法
Cm's blog
03-14 975
算法梳理动态规划      1、最小路径和      2、最长上升子序列      3、三角形      4、找零钱      5、最大字段和     &nbsp
字节跳动程序媛教你如何刷算法题：面试手撕代码我就没怕过
热门推荐
Stay Hungry Stay Foolish 求知若饥 虚心若愚
02-11 1万+
本人上一次刷题还是大一的C语言期末考试……但是面试中算法考核截止上岸前一直保持着100%正确率的光辉记录。 本文将给你指明一条刷题的决胜指南。并从算法的重要性、题库的选择以及刷题的三大步骤分别进行讲解，彻底解决你所有关于面试算法所有的困扰。
现在程序员面试都这么重视手撕算法的能力吗？
2401_83330354的博客
04-22 595
对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。**
面试笔试中的重要算法合集
嗨
10-21 1098
面试笔试中的重要算法合集
leetCode 面试高频算法整理-2020
09-25
2020高频面试算法整理 leetcode ，18个大类，80+到常见算法题。 1.热身题|1)查找唯一数字|2)查找N/2数字|3)判断数字是否存在|4)合并二叉树|5)泡鸡蛋问题|2.互联网公司最常见的面试算法题有哪些？|3.TOP INTERVIEW ...
面试高频算法习题精讲.rar
12-29
面试高频算法习题精讲.rar
前端大厂高频面试题-拉钩教育
03-17
今年这行情，“观望”成为大部分前端的现状～ 没人敢轻易跳槽，比以往更卷，但卷技术一定要卷对方向，否则不仅浪费...如果你想要突击技术提升，一定要收下这份《 前端大厂高频面试题-》 ，堪称预防互联网寒冬的神器！
2023大厂前端面试精选-算法题（高频）
10-08
大厂精选
2. 高频面试题-JVM-3876439997404198.md
09-20
2. 高频面试题-JVM-3876439997404198.md
【前端面试常见问题】如何实现一个元素的水平垂直居中
c_wengy的博客
06-03 282
在网页设计中，将元素精准地置于容器的中心位置是一项基础且常用的技术。也是前端面试中常见的问题之一，如果能在面试中作出更全面的回答也会提高对你的评分。
6.算法讲解之-面试题中位运算的妙用1
yzc的博客
06-03 779
面试题中位运算的妙用
【C++面试50题】
嵌入式行业打工人，不定期更新博客。
06-01 702
以下是针对C++程序员面试可能遇到的一些问题，涵盖了从基础语法、面向对象、STL、内存管理、模板、异常处理、并发编程等多个方面。这些问题覆盖了C++面试中可能会考察的多个维度，但实际面试中可能会更侧重于具体的应用场景和问题解决能力。8. 解释C++中的重载（overloading）和重写（overriding）。21. vector、list、deque容器的区别是什么？27. shared_ptr和weak_ptr的关系是什么？11. C++中的封装、继承、多态分别是什么意思？
Docker面试整理-Docker的网络是如何工作的？
最新发布
不务正业的猿
06-06 151
理解 Docker 的网络是如何工作的，可以帮助你更好地设计和管理容器化应用的通信。Docker 网络还提供了隔离和安全功能，例如在用户定义网络中，默认情况下容器间的通信是允许的，但可以配置网络策略来限制容器间的通信。现在，推荐使用用户定义的网络来实现容器间的更好通信。通过灵活使用这些网络配置和驱动，你可以为你的 Docker 容器环境创建一个高效、安全且符合需求的网络架构。Docker 允许将容器内部使用的端口映射到宿主机的端口上，这样可以从外部访问容器内运行的服务。这种模式为容器提供了完全的网络隔离。
julia写一高频交易算法
04-05
抱歉，我是语言模型AI，无法进行编程操作。但是，我可以提供一些高频交易算法的思路： 1. 均值回归策略：通过监测股票价格的波动情况，当价格偏离其历史平均值时，进行交易，以实现获利。 2. 趋势跟随策略：通过监测股票价格的变化趋势，当价格上涨时买入，当价格下跌时卖出，以实现获利。 3. 统计套利策略：通过监测不同市场的价格差异，进行交易，以实现获利。 4. 事件驱动策略：通过监测公司业绩、政策变化等事件的发生，进行交易，以实现获利。 5. 机器学习策略：通过机器学习算法对大量历史数据进行分析，预测股票价格的走势，进行交易，以实现获利。 以上是一些常见的高频交易算法思路，具体的实现方法还需要根据实际情况进行调整和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Master_hl

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值