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

最新推荐文章于 2024-04-30 20:06:58 发布
最新推荐文章于 2024-04-30 20:06:58 发布
阅读量1.4k 收藏 22
点赞数 52
分类专栏： ⑧Offer必备算法（由易到难刷题） ⑤高阶数据结构与算法（C++描述） 文章标签： 算法 动态规划 c++ leetcode 完全背包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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 = 0; j <= V; ++j)
        {
            if(j >= v[i])
                dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]);
            else
                dp[i][j] = dp[i - 1][j];
        }
    }
    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 = 0; j <= V; ++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]);
            else
                dp[i][j] = dp[i - 1][j];
        }
    }
    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)
            {
                if(j >= coins[i - 1])
                    dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i - 1]] + 1);
                else
                    dp[i][j] = dp[i - 1][j];
            }
        }
        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)
            {
                if(j >= coins[i - 1])
                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]];
                else
                    dp[i][j] = dp[i - 1][j];
            }
        }
        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] 。

解析代码

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

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

        先看能不能将问题转化成我们熟悉的题型。这里给出一个用拆分出相同子问题的方式，定义一个状态表示。（得到的结果 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。

GR鲸鱼
关注
  • 52
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Leet Code_力扣原题_leetcode官网_
10-01
力扣网原题，可用于求职刷题，每个程序代码都正确。
Offer必备算法_01双指针_八道力扣OJ题详解（由易到难）
参考书籍：《C语言程序设计》《数据结构》、《C++ Primer》、《Effective C++》、《STL源码剖析》、《现代操作系统》、《图解TCP/IP》、《图解HTTP》、《Linux高性能服务器编程》、《剑指Offer》、《算法导论》
01-21 1219
Offer必备算法01_双指针_八道力扣OJ题详解，力扣283+1089+202+11+611+15+18+剑指Offer57。（由易到难）
Offer必备算法16_字符串_四道力扣题详解（由易到难）
参考书籍：《C语言程序设计》《数据结构》、《C++ Primer》、《Effective C++》、《STL源码剖析》、《现代操作系统》、《图解TCP/IP》、《图解HTTP》、《Linux高性能服务器编程》、《剑指Offer》、《算法导论》
03-20 1801
Offer必备算法16_字符串_四道力扣题详解（①力扣14. 最长公共前缀+②力扣5. 最长回文子串+③力扣67. 二进制求和+④力扣43. 字符串相乘）
Offer必备算法08_二叉树dfs_六道力扣题详解（由易到难）
参考书籍：《C语言程序设计》《数据结构》、《C++ Primer》、《Effective C++》、《STL源码剖析》、《现代操作系统》、《图解TCP/IP》、《图解HTTP》、《Linux高性能服务器编程》、《剑指Offer》、《算法导论》
02-24 1924
Offer必备算法08_二叉树dfs_六道力扣题详解（由易到难）力扣2331计算布尔二叉树的值+力扣129求根节点到叶节点数字之和+力扣8146二叉树剪枝+力扣98验证二叉搜索树+力扣230二叉搜索树中第K小的元素+力扣257二叉树的所有路径。
leetcode第四题-LeetCode_Exercise:力扣_练习
07-01
结束了一些位操作和位掩码练习，难度由低到高总结了几道非常讲的位运算和位掩码题，难度由低到高 （简单的） （简单的） （强烈推荐） （中等的） （中）（强烈推荐） （中）（强烈推荐，即使你能想到每个元素出现4...
Python算法题源代码-LeetCode(力扣)-全排列
02-26
力扣热题Python源代码 题目46. 全排列 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1...
Python算法题源代码-LeetCode(力扣)-子集
02-27
力扣热题Python源代码 题目78. 子集 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 示例 1： 输入：nums = [1,2...
Python算法题源代码-LeetCode(力扣)-搜索插入位置
03-07
力扣热题Python源代码 题目35. 搜索插入位置 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的...
Codeforces Round 941 (Div. 2) （A~D）
weixin_61825750的博客
04-28 697
然后考虑若此时存在两个堆，那么对于Alice而言，其操作可以使得小的那个堆只剩下1，下一步Bob必须选1，然后Alice就胜利了。相反，若小的那个堆一开始就是1，那么Alice就输了。接下来推广到若干堆的情况：对于任意一方而言，若最小堆不是1，那么便可以控制胜利，于是我们只需要枚举到最小堆不是1的情况即可，然后看是谁在操作就是谁赢。思路：若要使得所有方格同色，关键在于四个角上的颜色，若对角上的颜色一样就能直接将所有格子变为同色。思路：首先处理 < k 的部分，我们可以通过二进制的思想来构造整数，例如。
算法训练营第十一天 | LeetCode 20 有效的括号、LeetCode 1047 删除字符串中的所有相邻重复项
qq_63149342的博客
04-27 114
注意用的是字符串数组作为输入，而我们要用int型进行计算，这时候就要用到一个string转int类型的库函数stoi函数，aoti是字符数组转int类型。一个是最后循环结束后要判断栈内存是否为空，一个是出栈时要判断栈是否为空，总的来说是考验对于栈内存空间的掌控吧。这一题考栈的性质，相邻字符用未进栈的元素和进栈的元素进行模拟即可，相同且栈不为空即出栈，否则进栈，之后将栈内元素全部导入一个字符串，还要注意要写一个反转函数翻转下即可。LeetCode 1047 删除字符串中的所有相邻重复项。
Golang | Leetcode Golang题解之第56题合并区间
weixin_66442839的博客
04-28 446
Golang | Leetcode Golang题解之第56题合并区间
4/26发布发布：缺了好几次的作业，矩形法+二分法求下面方程根+顺序查找n+程序填空，补一下还有八九没做，炸8412 字不是干的，哈哈哈
2201_75637762的博客
04-26 1235
eps：用于定义逼近的精度，即当x1和x2的差小于eps时，认为找到了根。x1和x2：用于二分法的初始区间，这里选择的是[-10, 10]。y1和y2：分别是x1和x2处函数的值。这个程序通过二分法在一个给定的区间内寻找三次方程的根。它首先检查函数在区间端点的值的符号，然后使用二分法逐步缩小区间，直到找到满足精度要求的根或确定区间内没有根为止。okll测试数据：3 4 7 12 24 78 9 15 80 45第一次运行程序输入测试数据 12。
算法~本质
最新发布
sweet_Mary的博客
04-30 250
数据结构分为数组和链表，数据结构的目的是提升增删改查的效率。算法的本质是基于这两种数据结构进行高效穷举。2.如何聪明地穷举？--并查集/贪心/KMP）数组--二分搜索/双指针/滑动窗口/前缀+差分。二叉树系列（回溯算法+动态规划）eg.求二叉树最大深度。2. 分解问题计算答案。2.分解问题计算答案。eg.二叉树前缀遍历。
代码随想录算法训练营Day25 | 216.组合总和III、17.电话号码的字母组合 | Python | 个人记录向
Python基本算法
04-27 637
回溯算法：216.组合总和III、17.电话号码的字母组合。
c入门基础题（3）
梦昼初
04-26 886
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
【C++中的模板】
Z15255808023的博客
04-27 727
本片内容主要是C++中模板的有关知识，主要讲述了模板及其实用和注意事项，请耐心观看。相必我们大家都听说过泛型编程这个概念：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。简单的说就是编写一种可以在多种数据类型上都能用的代码。比如说，你写一次代码，就可以在很多不同的数据类型上使用，而不需要为每种数据类型都重新写一遍相同逻辑的代码。它能让编程变得更简单、更灵活。
使用rust学习基本算法（四）
weixin_40539956的博客
04-27 978
对于一个包含n个顶点的图，其邻接矩阵是一个n×n的矩阵，记为A。如果顶点i和顶点j之间存在一条边，则矩阵中的元素A[i][j]表示这条边的权重；如果不存在边，则A[i][j]的值通常设为0（对于无权图）或某个特定的非负值，如无穷大（对于有权图），表示两个顶点之间没有直接的连接。
【算法】五子连线
qq_59306099的博客
04-25 391
棋盘一般为15X15的，横向为A～O，纵向为1～15，从棋盘的左下角开始标记，如下图所示。例如，图示中上面的5个棋子可标记为G13、H13、I13、J13、K13，正好形成横向五子连线的情况；图示中左下方的5个棋子可标记为H7、F5、E4、D3、C2，未能形成五子连线的情况。五子棋是世界智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏，通常双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成连续的五子连线（横、竖、斜）者获胜。接下来有n行数据，每行一组数据，每组数据包括5个棋子的位置。
【力扣】16. 最接近的三数之和
嵌入式小菜鸟一枚~
04-25 387
【力扣】16. 最接近的三数之和
javascript力扣算法题库
10-12
好的，你想了解 JavaScript力扣算法题库，这是一个非常好的主题。JavaScript力扣算法题库是一个包含各种算法问题的在线平台，它提供了许多有趣的问题，可以帮助你提高你的编程技能。你可以在这个平台上找到各种难度级别的问题，从简单的问题到复杂的问题都有。你可以通过解决这些问题来提高你的编程技能和算法思维能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

GR鲸鱼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值