Offer必备算法27_完全背包_四道力扣题（由易到难）

已于 2025-03-30 16:57:43 修改
阅读量1.6k 收藏 22
点赞数 52
分类专栏： ⑧Offer必备算法（由易到难刷题） ⑤高阶数据结构与算法（C++描述） 文章标签： 算法 动态规划 c++ leetcode 完全背包
于 2024-04-18 12:35:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/GRrtx/article/details/136857833
版权

目录

①牛客DP42 【模板】完全背包

问题一解析

问题二解析

解析代码

优化代码（滚动数组）

②力扣322. 零钱兑换

问题解析

解析代码

优化代码（滚动数组）

③力扣518. 零钱兑换 II

问题解析

解析代码

优化代码（滚动数组）

④力扣279. 完全平方数

问题解析

解析代码

优化代码（相同子问题分析和滚动数组）

本篇完。

①牛客DP42 【模板】完全背包

【模板】完全背包_牛客题霸_牛客网

问题一解析

        状态表示： dp[i][j] 表示：从前 i 个物品中挑选，总体积不超过 j ，所有的选法中，能挑选出来的最大价值。（这里和 01背包一样）

状态转移方程：

        线性 dp 状态转移方程分析方式，一般都是根据最后一步的状况，来分情况讨论。但是最后一个物品能选很多个，因此需要分很多情况：

  • 选 0 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j 。此时最大价值为 dp[i - 1][j] ;
  • 选 1 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j -v[i] 。因为挑选了一个 i 物品，此时最大价值为 dp[i - 1][j - v[i]] +w[i] ;
  • 选 2 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j- 2 * v[i] 。因为挑选了两个 i 物品，此时最大价值为 dp[i - 1][j - 2 * v[i]] + 2 * w[i] ;
  • ......

综上，状态转移方程为：

dp[i][j]=max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i], dp[i - 1][j - 2*v[i]]+2*w[i] ......)

        这时发现，计算一个状态的时候，需要一个循环才能搞定的时候，我们要想到去优化。优化的方向就是用一个或者两个状态来表示这一堆的状态，通常就是用数学的方式做一下等价替换。

        发现第二维是有规律的变化的，因此去看看 dp[i][j - v[i]] 这个状态： dp[i][j - v[i]]=max(dp[i - 1][j - v[i]],dp[i - 1][j - 2*v[i]]+w[i],dp[i - 1] [j - 3*v[i]]+2*w[i] ......)

        发现，把 dp[i][j - v[i]] 加上 w[i] 正好和 dp[i][j] 中除了第一项以外的全部一致，因此可以修改我们的状态转移方程为： dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]) 。（j >= v[i]）

初始化： 多加一行，方便初始化，此时仅需将第一行初始化为 0 即可。因为什么也不选，也能满足体积不小于 j 的情况，此时的价值为 0 。

填表顺序： 根据状态转移方程，仅需从上往下填表。

返回值： 根据状态表示，返回 dp[n][V] 。

问题二解析

        和01背包模板的问题一转换成问题二类似。第二问仅需微调一下 dp 过程的五步即可。 因为有可能凑不齐 j 体积的物品，因此把不合法的状态设置为 -1 。

状态表示： dp[i][j] 表示：从前 i 个物品中挑选，总体积正好等于 j ，所有的选法中，能挑选出来的最大价值。

状态转移方程：

        线性 dp 状态转移方程分析方式，一般都是根据最后一步的状况，来分情况讨论。但是最后一个物品能选很多个，因此需要分很多情况：

  • 选 0 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j 。此时最大价值为 dp[i - 1][j] ;
  • 选 1 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j -v[i] 。因为挑选了一个 i 物品，此时最大价值为 dp[i - 1][j - v[i]] +w[i] ;
  • 选 2 个第 i 个物品：此时相当于就是去前 i - 1 个物品中挑选，总体积不超过 j- 2 * v[i] 。因为挑选了两个 i 物品，此时最大价值为 dp[i - 1][j - 2 * v[i]] + 2 * w[i] ；
  • ......

综上，状态转移方程为：

dp[i][j]=max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i], dp[i - 1][j - 2*v[i]]+2*w[i] ......)

        这时发现，计算一个状态的时候，需要一个循环才能搞定的时候，我们要想到去优化。优化的方向就是用一个或者两个状态来表示这一堆的状态，通常就是用数学的方式做一下等价替换。

        发现第二维是有规律的变化的，因此去看看 dp[i][j - v[i]] 这个状态： dp[i][j - v[i]]=max(dp[i - 1][j - v[i]],dp[i - 1][j - 2*v[i]]+w[i],dp[i - 1] [j - 3*v[i]]+2*w[i] ......)

        发现，把 dp[i][j - v[i]] 加上 w[i] 正好和 dp[i][j] 中除了第一项以外的全部一致，因此可以修改我们的状态转移方程为： dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]) 。（j >= v[i] ， dp[i][j - v[i]] != -1 。）

初始化： 多加一行，方便初始化，第一个格子为 0 ，因为正好能凑齐体积为 0 的背包，但是第一行后面的格子都是 -1 ，因为没有物品，无法满足体积大于 0 的情况。

填表顺序： 根据状态转移方程，仅需从上往下填表。

返回值： 根据状态表示，返回 dp[n][V] 。由于最后可能凑不成体积为 V 的情况，因此返回之前需要特判一下。

解析代码

#include <iostream>
#include <cstring>
using namespace std;
 
const int N = 1010;
int n = 0, V = 0;
int v[N], w[N], dp[N][N];
 
int main()
{
    // dp[i][j] 表示：从前 i 个物品中挑选，总体积不超过 j ，所有的选法中，能挑选出来的最大价值
    cin >> n >> V;
    for(int i = 1; i <= n; i++) 
    {
        cin >> v[i] >> w[i];
    }
    for(int i = 1; i <= n; ++i) // 第一问
    {
        for(int j = 1; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i])
                dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]);
        }
    }
    cout << dp[n][V] << endl;
 
    memset(dp, 0, sizeof(dp)); // 第二问
    for(int j = 1; j <= V; j++)
    {
        dp[0][j] = -1;
    }
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= V; ++j)
        {
            dp[i][j] = dp[i - 1][j];
            if(j >= v[i] && dp[i][j - v[i]] != -1)
                dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]);
        }
    }
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
    return 0;
}

优化代码（滚动数组）

背包问题基本上都是利用滚动数组来做空间上的优化：

  1. 利用滚动数组优化。
  2. 直接在原始代码上修改。

在完全背包问题中，优化的结果为：

  1. 仅需删掉所有的横坐标。

（填一行数组的值的时候要用到前面新填的值，所以依旧是从左往右遍历，01背包是从右往左）

#include <iostream>
#include <cstring>
using namespace std;

const int N = 1010;
int n = 0, V = 0;
int v[N], w[N], dp[N]; // 滚动数组优化，删掉dp表的一维

int main()
{
    // dp[i][j] 表示：从前 i 个物品中挑选，总体积不超过 j ，所有的选法中，能挑选出来的最大价值
    cin >> n >> V;
    for(int i = 1; i <= n; i++) 
    {
        cin >> v[i] >> w[i];
    }
    for(int i = 1; i <= n; ++i) // 第一问
    {
        for(int j = v[i]; j <= V; ++j)
        {
            // if(j >= v[i]) // 滚动数组优化，从v[i]开始遍历，就不用判断
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    cout << dp[V] << endl;

    memset(dp, 0, sizeof(dp)); // 第二问
    for(int j = 1; j <= V; j++)
    {
        dp[j] = -1;
    }
    for(int i = 1; i <= n; ++i)
    {
        for(int j = v[i]; j <= V; ++j)
        {
            if(dp[j - v[i]] != -1)
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    cout << (dp[V] == -1 ? 0 : dp[V]) << endl;
    return 0;
}

②力扣322. 零钱兑换

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
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {

    }
};

问题解析

先看能不能将问题转化成我们熟悉的题型。

  • 在一些物品中挑选一些出来，然后在满足某个限定条件下，解决一些问题，大概率是背包模型；
  • 由于每一个物品都是无限多个的，因此是一个完全背包问题。接下来的分析就是基于完全背包的方式来

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

状态转移方程：

        线性 dp 状态转移方程分析方式，一般都是根据最后一步的状况，来分情况讨论。但是最后一个物品能选很多个，因此需要分很多情况：

  • 选 0 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j 。 此时最少的硬币个数为 dp[i - 1][j] 
  • 选 1 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - v[i] 。因为挑选了一个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - coins[i]] + 1 ;
  • 选 2 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - 2 * coins 。因为挑选了两个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - 2 * coins[i]] + 2 ;
  • ......

综上，状态转移方程为：

dp[i][j]=min(dp[i - 1][j], dp[i - 1][j - coins[i]] + 1, dp[i - 1][j - 2*coins[i]] + 2 ......)

        这时发现，计算一个状态的时候，需要一个循环才能搞定的时候，我们要想到去优化。优化的方向就是用一个或者两个状态来表示这一堆的状态，通常就是用数学的方式做一下等价替换。

        发现第二维是有规律的变化的，因此去看看 dp[i][j - v[i]] 这个状态： dp[i][j - v[i]]=min(dp[i - 1][j - coins[i]] + 1,dp[i - 1][j - 2*coins[i]]] + 2,dp[i - 1] [j - 3*coins[i]] + 3......)

        因此可以修改我们的状态转移方程为： dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]] + 1) 。（j >= coins[i] ， dp[i][j - coins[i]] 存在 。）（如果初始化多开一行一列，找coins数组要减一）

有个技巧，就是相当于把第二种情况 dp[i - 1][j - coins[i]] + 1 ⾥ ⾯的 i - 1 变成 i 即可。

初始化： dp[0[0]为0，初始化第一行即可。 这里因为取 min ，所以可以把无效的地方设置成无穷大 （0x3f3f3f3f） 因为这里要求正好凑成总和为 j ，因此，需要把第一行除了第一个位置的元素，都设置成无穷大。

填表顺序： 根据状态转移方程，仅需从上往下填表。

返回值： 根据状态表示，返回 dp[n][amount] 。由于最后可能凑不成总数为 amount 的情况，因此返回之前需要特判一下。

解析代码

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        const int INF = 0x3f3f3f3f; // 无穷大的一半
        int n = coins.size();
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1, INF));
        // dp[i][j]表示：从前i个硬币中挑选，总和正好等于j，所有的选法中，最少的硬币个数
        dp[0][0] = 0;
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 0; j <= amount; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= coins[i - 1])
                    dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i - 1]] + 1);
            }
        }
        return dp[n][amount] >= INF ? -1 : dp[n][amount];
    }
};

优化代码（滚动数组）

背包问题基本上都是利用滚动数组来做空间上的优化：

  1. 利用滚动数组优化。
  2. 直接在原始代码上修改。

在完全背包问题中，优化的结果为：

  1. 仅需删掉所有的横坐标。

（填一行数组的值的时候要用到前面新填的值，所以依旧是从左往右遍历，01背包是从右往左）

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        const int INF = 0x3f3f3f3f; // 无穷大的一半
        int n = coins.size();
        vector<int> dp(amount + 1, INF);
        dp[0] = 0;
        for(int i = 1; i <= n; ++i)
        {
            for(int j = coins[i - 1]; j <= amount; ++j)
            {
                dp[j] = min(dp[j], dp[j - coins[i - 1]] + 1);
            }
        }
        return dp[amount] >= INF ? -1 : dp[amount];
    }
};

③力扣518. 零钱兑换 II

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
class Solution {
public:
    int change(int amount, vector<int>& coins) {

    }
};

问题解析

先看能不能将问题转化成我们熟悉的题型。

  • 在一些物品中挑选一些出来，然后在满足某个限定条件下，解决一些问题，大概率是背包模型
  • 由于每一个物品都是无限多个的，因此是一个完全背包问题。接下来的分析就是基于完全背包的方式来

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

状态转移方程：

        线性 dp 状态转移方程分析方式，一般都是根据最后一步的状况，来分情况讨论。但是最后一个物品能选很多个，因此需要分很多情况：

  • 选 0 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j 。 此时最少的硬币个数为 dp[i - 1][j] 
  • 选 1 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - v[i] 。因为挑选了一个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - coins[i]] + 1 ;
  • 选 2 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j - 2 * coins 。因为挑选了两个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - 2 * coins[i]] + 2 ;
  • ......

综上，状态转移方程为：

dp[i][j] = dp[i - 1][j] + dp[i - 1][j - coins[i]] + 1 + dp[i - 1][j - 2*coins[i]] + 2 +  ......

        这时发现，计算一个状态的时候，需要一个循环才能搞定的时候，我们要想到去优化。优化的方向就是用一个或者两个状态来表示这一堆的状态，通常就是用数学的方式做一下等价替换。

        发现第二维是有规律的变化的，因此去看看 dp[i][j - v[i]] 这个状态： dp[i][j - v[i]] = dp[i - 1][j - coins[i]] + 1 + dp[i - 1][j - 2*coins[i]]] + 2 + dp[i - 1] [j - 3*coins[i]] + 3 + ......

        因此可以修改我们的状态转移方程为： dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]] + 1)。（j >= coins[i] ， dp[i][j - coins[i]] 存在 。）（如果初始化多开一行一列，找coins数组要减一）

有个技巧，就是相当于把第二种情况 dp[i - 1][j - coins[i]] + 1 里面的 i - 1 变成 i 即可。

初始化： dp[0[0]为0，初始化第一行即可。第一行表示没有物品，没有物品正好能凑能和为 0 的情况。因此 dp[0][0] = 1 ，其余位置都是 0 种情况。

填表顺序： 根据状态转移方程，仅需从上往下填表。

返回值： 根据状态表示，返回 dp[n][amount] 。

解析代码

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        // dp[i][j]表示：从前i个硬币中挑选，总和正好等于j ，一共有多少种选法
        int n = coins.size();
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1, 0));
        dp[0][0] = 1;
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 0; j <= amount; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if(j >= coins[i - 1])
                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]];
            }
        }
        return dp[n][amount];
    }
};

优化代码（滚动数组）

背包问题基本上都是利用滚动数组来做空间上的优化：

  1. 利用滚动数组优化。
  2. 直接在原始代码上修改。

在完全背包问题中，优化的结果为：

  1. 仅需删掉所有的横坐标。

（填一行数组的值的时候要用到前面新填的值，所以依旧是从左往右遍历，01背包是从右往左）

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();
        vector<int> dp(amount + 1, 0); // 滚动数组优化
        dp[0] = 1;
        for(int i = 1; i <= n; ++i)
        {
            for(int j = coins[i - 1]; j <= amount; ++j)
            {
                dp[j] = dp[j] + dp[j - coins[i - 1]];
            }
        }
        return dp[amount];
    }
};

④力扣279. 完全平方数

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
class Solution {
public:
    int numSquares(int n) {

    }
};

问题解析

（优化代码部分放了分析一维空间的思路，这个普通思路就简单描述了）

状态表示： dp[i][j] 表示：从前i个完全平方数中挑选，总和正好等于j，所有选法中最小的数量。

状态转移方程：

        线性 dp 状态转移方程分析方式，一般都是根据最后一步的状况，来分情况讨论。但是最后一个物品能选很多个，因此需要分很多情况：

  • 选 0 个i * i：dp[i][j] = dp[i - 1][j] 
  • 选 1 个i * i：dp[i][j] = dp[i - 1][j - i * i] + 1 ;
  • 选 2 个i * i：dp[i][j] = dp[i - 1][j - 2 * i * i] + 2 ;
  • ......

综上，状态转移方程为：

dp[i][j] = min(dp[i - 1][j] , dp[i - 1][j - i * i] + 1 + dp[i - 1][j - 2 * i * i] + 2 ,  ......)

        这时发现，计算一个状态的时候，需要一个循环才能搞定的时候，我们要想到去优化。优化的方向就是用一个或者两个状态来表示这一堆的状态，通常就是用数学的方式做一下等价替换。

        发现第二维是有规律的变化的，因此去看看 dp[i][j - i * i] + 1 ; 这个状态： dp[i][j - i * i] + 1 = min( dp[i - 1][j - 2 * i * i] + 2 , dp[i - 1][j - 3 * i * i] + 3  ,  ......)

        因此可以修改我们的状态转移方程为： dp[i][j] = min(dp[i - 1][j] , dp[i][j - i * i] + 1。（j >= i * i ）。有个技巧，就是相当于把第二种情况 dp[i - 1][j - i * i] + 1 里面的 i - 1 变成 i 即可。

初始化： 初始化第一行即可，dp[0[0]为1，第一行后面初始化成无穷大。

填表顺序： 根据状态转移方程，仅需从上往下填表。

返回值： 根据状态表示，返回 dp[根号n][n] 。

解析代码1

class Solution {
public:
    int numSquares(int n) {
        // 状态表示： dp[i][j] 表示：从前i个完全平方数中挑选，总和正好等于j，所有选法中最小的数量
        int m = sqrt(n);
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0x3f3f3f3f));
        dp[0][0] = 0;
        for(int i = 1; i <= m; ++i)
        {
            for(int j = 0; j <= n; ++j)
            {
                if(j >= i * i)
                    dp[i][j] = min(dp[i - 1][j], dp[i][j - i * i] + 1);
                else
                    dp[i][j] = dp[i - 1][j];
            }
        }
        return dp[m][n];
    }
};

解析代码2（滚动数组）

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();
        vector<int> dp(amount + 1, 0); // 滚动数组优化
        dp[0] = 1;
        for(int i = 1; i <= n; ++i)
        {
            for(int j = coins[i - 1]; j <= amount; ++j)
            {
                dp[j] = dp[j] + dp[j - coins[i - 1]];
            }
        }
        return dp[amount];
    }
};

解析代码3（相同子问题分析和滚动数组）

        先看能不能将问题转化成我们熟悉的题型。这里给出一个用拆分出相同子问题的方式，定义一个状态表示。（得到的结果 i 和 j 换一下就是滚动数组优化的结果）

为了叙述方便，把和为 n 的完全平方数的最少数量简称为最小数量。

对于 12 这个数，分析一下如何求它的最小数量。

  • 如果 12 本身就是完全平方数，就不用算了，直接返回 1 ;
  • 但是 12 不是完全平方数，试着把问题分解⼀下：
  1. 情况一：拆出来一个 1 ，然后看看 11 的最小数量，记为 x1 ；
  2. 情况二：拆出来一个 4 ，然后看看 8 的最小数量，记为 x2 ；（为什么拆出来 4 ， 而不拆出来 2 呢？）
  3. 情况三：拆出来一个 8 ...... 其中，接下来求 11、8 的时候，其实又回到了原来的问题上。

        因此，可以尝试用 dp 的策略，将 1 2 3 4 6 等等这些数的最小数量依次保存起来。再求较大的 n 的时候，直接查表，然后找出最小数量。

状态表示： dp[i] 表示：和为 i 的完全平方数的最少数量。

状态转移方程：

        对于 dp[i] ，根据思路里的分析知道，可以根据小于等于 i 的所有完全平方数 x 进行划分：

  • x = 1 时，最小数量为： 1 + dp[i - 1] ；
  • x = 4 时，最小数量为： 1 + dp[i - 4] ......

为了方便枚举完全平方数，采用的策略： for(int j = 1; j * j <= i; j++)

综上，状态转移方程为：

dp[i] = min(dp[i], dp[i - j * j] + 1)

初始化：当 n = 0 的时候，没法拆分，结果为 0 ； 当 n = 1 的时候，结果为 1 。

填表顺序： 根据状态转移方程，仅需从左往右填表。

返回值： 根据状态表示，返回 dp[n] 。

class Solution {
public:
    int numSquares(int n) {
        // dp[i] 表示：和为 i 的完全平方数的最少数量
        int m = sqrt(n);
        vector<int> dp(n + 1, 0x3f3f3f3f);
        dp[0] = 0;
        for(int i = 1; i <= m; ++i)
        {
            for(int j = i * i; j <= n; ++j)
            {
                dp[j] = min(dp[j], dp[j - i * i] + 1);
            }
        }
        return dp[n];
    }
};

本篇完。

下一篇是多源BFS类型的OJ。

下下篇动态规划类型的是其它背包问题（二维费用背包 + 似包非包 + 卡特兰数）的OJ。

（穿越回来复习顺便贴个下两篇链接：）

Offer必备算法28_多源BFS_四道力扣题详解（由易到难）-优快云博客

Offer必备算法29_其它背包问题_二维费用背包+似包非包+卡特兰数-优快云博客

[AcWing] 3. 完全背包问题（C++实现）完全背包问题模板题
cloud的博客
12-13 2674
[AcWing] 3. 完全背包问题（C++实现）完全背包问题模板题1. 题目2. 读题（需要重点注意的东西）3. 解法4. 可能有帮助的前置习题5. 所用到的数据结构与算法思想6. 总结 1. 题目 2. 读题（需要重点注意的东西） 思路： 闫式dp分析法 用闫式dp分析法分析完全背包问题 未进行优化 按以上思路，最朴素的做法 #include<iostream> using namespace std; const int N = 1010; int n,m; int v[N],
算法题解_力扣每日一题_代码调试方法_在线学习与实践指南_1741862807.zip
03-14
本压缩包文件名为“算法题解_力扣每日一题_代码调试方法_在线学习与实践指南_1741862807.zip”，它是一个集合了多种资源的压缩文件，旨在为C语言学习者提供算法题目解答、代码调试方法以及在线学习和实践的指导。...
完全背包问题模板（dp)
2401_87338545的博客
10-27 286
首先优化掉k循环，与k无关。dp[i][j-v[i]] = max(dp[i-1][j], dp[i][j-v[i]] + w[i]) 选品i时，选k和不选k时，哪一个打包值更大。然后优化掉i，不影响.因为可以重复选品i，所以不会有歧义，可以正向遍历更新。之前有歧义是因为担心选到自己之后，自身加自身的歧义，而这里不会。
【背包问题】完全背包
2401_82677021的博客
01-27 817
上篇：01背包优快云。
背包问题模板
weixin_39548163的博客
08-28 169
无优化： for(int i=1;i&lt;=n;i++) {     for(int c=0;c&lt;=m;c++)     {         f[i][c]=f[i-1][c];         if(c&gt;=w[i])         f[i][c]=max(f[i][c],f[i-1][c-w[i]]+v[i]);     } } 一维数组优化： for(int ...
（NYoj 311） 完全背包 --完全背包模板题
STILLxjy
08-05 992
完全背包 时间限制：3000 ms | 内存限制：65535 KB 难度：4 描述 直接说题意，完全背包定义有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的体积是c，价值是w。求解将哪些物品装入背包可使这些物品的体积总和不超过背包容量，且价值总和最大。本题要求是背包恰好装满背包时，求出最大价值总和是多少。如果不能恰好装满背包，输出NO输入 第一行： N 表示有多少组
完全背包模板
iwi
04-30 281
题目：完全背包问题思路：模板+滚动数组…代码：#include&lt;bits/stdc++.h&gt; using namespace std; #define maxm 200 #define maxn 30 int m,n; int w[maxn+5],c[maxn+5]; int f[maxm+5]= {0}; int main() { scanf("%d%d",&amp;m,&a...
Leet Code_力扣原题_leetcode官网_
10-01
1. **复习基础算法**：力扣原题涵盖了从基础到高级的各种算法，如二分查找、回溯法、动态规划等，这将帮助你巩固算法基础。 2. **提升编程技巧**：通过阅读他人的解决方案，你可以学习不同的编程风格和优化技巧。 3....
leetcode第四题-LeetCode_Exercise:力扣_练习
07-01
结束了一些位操作和位掩码练习，难度由低到高总结了几道非常讲的位运算和位掩码题，难度由低到高 （简单的） （简单的） （强烈推荐） （中等的） （中）（强烈推荐） （中）（强烈推荐，即使你能想到每个元素出现4...
算法解题_力扣助手_学习效率提升_公众号服务工具_1741873744.zip
最新发布
03-15
数据结构学习笔记
leetcode-js-roadmap::beaming_face_with_smiling_eyes:前端力扣刷图路线图（简单部分），已配置好调试环境，并提供每道题的力扣链接，欢迎Star~
05-26
不积跬步无以至千里，许多人在学习算法的路上放弃，第一是因为起点太高，刚上来就做一些中等难度甚至困难的题，遇到挫折就很难坚持下去，就算刚开始从简单做起，也会在基础尚未牢固的情况下在中等难度下退缩；...
背包问题模板 hdu2191
06-24
背包问题的模板，可以解决各类背包问题，根据问题需要修改参数即可。试用于ACM初学者。
01背包问题/完全背包问题 滚动数组代码模板
弋墨尘的博客
06-22 749
01背包问题： 有 n 件物品， 每件物品的重量为 w[i], 价值为 c[i]。现有一个容量为 V 的背包， 问如何选取物品放入背包， 使得背包内物品的总价值最大。 其中每种物品都只有1件。 for(int i=0;i<c;i++){ for(int v=V;v>=w[i];v--){//逆向枚举 dp[v]=min(dp[v-w[i]]+c[i],dp[v]...
【完全背包】完全背包模板套用
liuwanqing233333的博客
10-16 877
完全背包问题模板套用
背包问题总结（模板）
Tmotfl的博客
10-31 490
01背包：  有n个物品，每个物品对应的价值和体积，且每个物品只能选一次，背包体积为V求背包所能装物品的最大价值#include&lt;iostream&gt; #include&lt;cstdio&gt; const int maxn=10002;//n表示物品个数 int f[maxn],v[maxn],val[maxn],V,n;//V表示背包体积 using namespace std...
ACM_模板_背包问题
RaAlGhul的博客
03-01 2263
背包问题是属于动态规划中的一种非常经典的运用，小编在这里大力推荐dd_engi的背包九讲，这种超级详细的讲解在小编心中是可以得到诺贝尔文学奖的~ 1.01背包 首先是最基础的01背包问题，所有元素只能使用一次，此问题只需要考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。如果不放第i件物品，那么问题就转化为“前i-1件物 品放入容量为v的背包中”，价值为f[i-...
[背包] 背包问题算法模板(模板)
Y-puyu 的博客
11-09 3047
文章目录0. 前言1. 01背包2. 完全背包3. 多重背包4. 分组背包 0. 前言 背包问题是众多 dp 问题的母题，是一个很重要的知识点。该博文基于背包九讲总结，会将背包九讲内容及模板题全部总结一般，也是鉴于学习进度，目前仅总结了 01 背包及优化模型，完全背包，多重背包，分组背包。 初次系统学习背包问题，总结不够到位，往各位同学批评指正！十分感谢~ 背包问题共性： n 个物品，一个容量为 v 的背包 每个物品两个属性，体积 vi，价值 wi 要求在这些物品中挑总体积不大于 v 的物品并使背包装入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GR鲸鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值