【从二维到一维：动态规划——01背包完全背包的空间优化之路】—— 经典例题解答，将问题转化为背包问题

于 2025-03-10 17:12:03 发布
阅读量1.2k 收藏 48
点赞数 52
分类专栏： 算法题 文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ZWW_zhangww/article/details/146120029
版权

文章目录

关于01背包中一维dp和二维dp的比较

  • 二维dp
    在 0/1 背包问题 中，二维DP的状态转移是 dp[i][j]，表示前 i 个物品中，是否能够装入容量为 j 的背包。

  • 一维dp
    在 0/1 背包问题 中，通常会优化为一维DP，使用一维数组 dp[j] 来表示当前背包容量为 j 时的最大价值。通过从右到左更新，避免了重复使用相同的物品。

在空间复杂度上：

  1. 空间复杂度：
    二维DP：通常是 O(n * m)，其中 n 和 m 是问题的两个维度。空间较大，尤其是在问题的规模增大时。
    一维DP：通常是 O(m)，通过滚动数组优化，只需要存储当前状态所需要的部分，显著降低空间复杂度。
  2. 时间复杂度：
    二维DP：与二维状态转移相关，因此时间复杂度通常是 O(n * m)，这里 n 和 m 是问题的两个维度。
    一维DP：时间复杂度通常与二维DP相同，但因为我们只使用一维数组，它通常能通过节省空间来获得更好的性能，尤其在状态可以滚动的情况下。
  3. 实现难度：
    二维DP：一般来说，二维DP的实现更加直观，直接反映了问题的结构。它适用于有多个独立维度需要考虑的问题。
    一维DP：实现相对复杂，特别是在需要滚动数组的情况下，需要通过巧妙的设计和状态转移来避免重复计算，但空间复杂度的优化是其主要优点。
  4. 代码可读性：
    二维DP：代码通常比较清晰，因为每个维度的状态都是明确的，比较容易理解。
    一维DP：通过“滚动”数组的优化，代码可能不如二维DP直观，特别是当涉及到倒序更新状态时。

二维dp代码

vector<vector<int>> dp(n + 1, vector<int>(W + 1, 0));
for (int i = 1; i <= n; i++) 
{
    for (int w = 0; w <= W; w++) 
    {
        dp[i][w] = dp[i-1][w];  // 不选当前物品
        if (w >= weights[i-1]) 
        {
            dp[i][w] = max(dp[i][w], dp[i-1][w-weights[i-1]] + values[i-1]);
        }
    }
}
return dp[n][W];

二维DP 中，我们需要一个 n+1 行，W+1 列的数组，dp[i][w] 表示前 i 个物品能够填充容量为 w 的背包。

一维dp代码

vector<int> dp(W + 1, 0);
for (int i = 1; i <= n; i++) 
{
    // 从大到小遍历，防止重复更新
    for (int w = W; w >= weights[i-1]; w--) 
    {
        dp[w] = max(dp[w], dp[w - weights[i-1]] + values[i-1]);
    }
}
return dp[W];

一维DP 中，我们只需要一个大小为 W+1 的数组 dp，它保存的是当前容量下的最大价值。通过倒序遍历 w，我们确保每个物品只更新一次，避免覆盖之前的状态。

【模板】01背包

在这里插入图片描述

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

const int N = 1010;  // 定义常量N，表示物品和容量的最大值
int n, v;  // n: 物品的数量, v: 背包的容量
int dp[N][N];  // dp数组，二维数组，其中dp[i][j]表示前i个物品放入容量为j的背包中所得到的最大价值
int V[N], w[N];  // V数组存储每个物品的体积，w数组存储每个物品的价值

int main() 
{
    cin >> n >> v;  // 输入物品数量n和背包容量v
    for(int i = 1; i <= n; i++)
    {
        cin >> V[i] >> w[i];  // 输入每个物品的体积V[i]和价值w[i]
    }

    // 0/1背包的动态规划过程
    // i表示物品的编号，j表示背包容量
    for(int i = 1; i <= n; i++)  // 遍历每个物品
    {
        for(int j = 1; j <= v; j++)  // 遍历每个背包容量
        {
            dp[i][j] = dp[i - 1][j];  // 不选当前物品，最大价值为前i-1个物品在容量j下的最大价值
            if(j - V[i] >= 0)  // 如果背包容量j足够放下当前物品
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - V[i]] + w[i]);  // 选择当前物品或不选择当前物品
        }
    }
    cout << dp[n][v] << endl;  // 输出使用动态规划后的最大价值

    // 重置dp数组，并进行第二次动态规划
    memset(dp, 0, sizeof(dp));  // 重置dp数组，初始化为0
    for(int j = 1; j <= v; j++) dp[0][j] = -1;  // dp[0][j]表示选择第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 - 1][j - V[i]] != -1)  // 判断当前背包容量是否足够，且前一个状态有效
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - V[i]] + w[i]);  // 选择当前物品或不选择
        }
    }

    // 输出第二次动态规划后的最大价值，如果dp[n][v]为-1，说明无法填充背包，输出0，否则输出最大价值
    cout << (dp[n][v] == -1 ? 0 : dp[n][v]) << endl;

    return 0;
}

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

const int N = 1010;  // 定义一个常量N表示物品数量的最大值（最大背包容量为v）
int n, v;  // n为物品数量，v为背包容量
int dp[N];  // dp数组，用来存储每个容量下能够获得的最大价值
int V[N], w[N];  // V数组存储每个物品的体积，w数组存储每个物品的价值

int main() 
{
    cin >> n >> v;  // 输入物品的数量n和背包的容量v
    for(int i = 1; i <= n; i++)
    {
        cin >> V[i] >> w[i];  // 输入每个物品的体积V[i]和价值w[i]
    }

    // 0/1背包动态规划
    // i表示是否选择物品i，j表示当前背包容量剩余空间
    for(int i = 1; i <= n; i++)  // 遍历每个物品
    {
        for(int j = v; j >= V[i]; j--)  // 遍历容量从v到V[i]（逆序保证每个物品只能选择一次）
        {
            dp[j] = max(dp[j], dp[j - V[i]] + w[i]);  // 选择当前物品，更新dp[j]
        }
    }
    cout << dp[v] << endl;  // 输出使用0/1背包的最大价值

    memset(dp, 0, sizeof(dp));  // 重置dp数组
    for(int j = 1; j <= v; j++) dp[j] = -1;  // 初始化dp数组，-1表示无法达到该容量
    for(int i = 1; i <= n; i++)  // 遍历每个物品
    {
        for(int j = v; j >= V[i]; j--)  // 遍历容量从v到V[i]（逆序保证每个物品只能选择一次）
        {
            if(dp[j - V[i]] != -1)  // 判断前一个状态是否有效
                dp[j] = max(dp[j], dp[j - V[i]] + w[i]);  // 如果有效，更新dp[j]
        }
    }

    cout << (dp[v] == -1 ? 0 : dp[v]) << endl;  // 输出使用另一种方式计算的最大价值
    return 0;
}

分割等和子集

在这里插入图片描述

class Solution 
{
public:
    bool canPartition(vector<int>& nums) 
    {
        int n = nums.size();  // 数组的长度
        int sum = accumulate(nums.begin(), nums.end(), 0);  // 计算数组元素的总和
        
        // 如果总和是奇数，无法平分为两个相等的子集
        if(sum % 2 == 1) return false;
        
        // 目标是找到和为 sum / 2 的子集
        vector<vector<bool>> dp(n + 1, vector<bool>(sum / 2 + 1));  // dp[i][j] 表示是否可以通过前 i 个元素，得到和为 j 的子集
        
        // 初始化：当目标和为 0 时，任何前 i 个元素都可以通过不选择元素得到和为 0
        for(int i = 0; i <= n; i++) dp[i][0] = true;
        
        // 遍历每一个元素，更新 dp 数组
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= sum / 2; j++)
            {
                dp[i][j] = dp[i - 1][j];  // 不选当前元素，dp[i][j]继承自上一个元素的状态
                if(j >= nums[i - 1])  // 如果当前目标和 j 大于或等于当前元素 nums[i - 1]
                    dp[i][j] = dp[i][j] || dp[i - 1][j - nums[i - 1]];  // 可以选择当前元素，或者不选
            }
        }
        
        // 最终结果：是否存在和为 sum / 2 的子集
        return dp[n][sum / 2];
    }
};

class Solution 
{
public:
    bool canPartition(vector<int>& nums) 
    {
        int n = nums.size();  // 数组的长度
        int sum = accumulate(nums.begin(), nums.end(), 0);  // 计算数组元素的总和
        
        // 如果总和是奇数，无法平分为两个相等的子集
        if(sum % 2 == 1) return false;
        
        // 目标是找到和为 sum / 2 的子集
        vector<bool> dp(sum / 2 + 1);  // dp[i] 表示是否存在和为 i 的子集
        dp[0] = true;  // 和为 0 的子集一定存在（即不选择任何元素）
        
        // 遍历数组的每一个元素
        for(int i = 1; i <= n; i++)
        {
            // 从后往前更新 dp 数组，确保每个元素只使用一次
            for(int j = sum / 2; j >= nums[i - 1]; j--)
            {
                dp[j] = dp[j] || dp[j - nums[i - 1]];  // 如果可以达到 dp[j - nums[i - 1]]，则 dp[j] 也可以达到
            }
        }
        
        // 最后判断是否存在和为 sum / 2 的子集
        return dp[sum / 2];
    }
};

目标和

在这里插入图片描述

class Solution 
{
public:
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        int sum = accumulate(nums.begin(), nums.end(), 0);  // 计算数组的总和
        int n = nums.size();  // 数组的长度
        int aim = (sum + target) / 2;  // 目标和 P，要求 P = (sum + target) / 2
        
        // 如果目标和小于 0 或者 (sum + target) 不是偶数，返回 0
        if(aim < 0 || (sum + target) % 2) return 0;
        
        // dp[i][j] 表示在前 i 个元素中，是否存在一个子集，和为 j
        vector<vector<int>> dp(n + 1, vector<int>(aim + 1, 0));  // 初始化动态规划数组
        dp[0][0] = 1;  // 和为 0 时，选取 0 个元素的方式只有 1 种，即不选任何元素
        
        // 遍历每个元素
        for(int i = 1; i <= n; i++)
        {
            // 遍历所有可能的子集和 j
            for(int j = 0; j <= aim; j++)
            {
                dp[i][j] = dp[i - 1][j];  // 不选择当前元素，继承上一个状态
                
                // 如果当前目标和 j 大于等于当前元素 nums[i - 1]，可以选择当前元素
                if(j >= nums[i - 1])
                {
                    dp[i][j] += dp[i - 1][j - nums[i - 1]];  // 选择当前元素时，更新 dp 状态
                }
            }
        }
        
        // 最终结果：dp[n][aim] 表示是否能选出和为 aim 的子集
        return dp[n][aim];
    }
};

class Solution 
{
public:
    int findTargetSumWays(vector<int>& nums, int target) 
    {
        int sum = accumulate(nums.begin(), nums.end(), 0);  // 计算数组的总和
        int n = nums.size();  // 数组的长度
        int aim = (sum + target) / 2;  // 目标和 P，要求 P = (sum + target) / 2
        
        // 如果目标和小于 0 或者 (sum + target) 不是偶数，返回 0
        if(aim < 0 || (sum + target) % 2) return 0;
        
        // dp[j] 表示是否能选出和为 j 的子集
        vector<int> dp(aim + 1, 0);  // 初始化一维动态规划数组
        dp[0] = 1;  // 和为 0 时，选取 0 个元素的方式只有 1 种，即不选任何元素
        
        // 遍历每个元素
        for(int i = 1; i <= n; i++)
        {
            // 从后往前更新 dp 数组，确保每个元素只用一次
            for(int j = aim; j >= nums[i - 1]; j--)
            {
                dp[j] = dp[j] + dp[j - nums[i - 1]];  // 更新 dp[j]，增加当前元素的选择
            }
        }
        
        // 最终结果：dp[aim] 表示能否选出和为 aim 的子集
        return dp[aim];
    }
};

最后一块石头重量||

在这里插入图片描述

class Solution 
{
public:
    int lastStoneWeightII(vector<int>& stones) 
    {
        int n = stones.size();  // 获取石头的数量
        int sum = accumulate(stones.begin(), stones.end(), 0);  // 计算所有石头的总和
        int aim = sum / 2;  // 目标是找到一个和尽量接近 sum / 2 的子集
        
        // dp[i][j] 表示前 i 块石头中，是否能组成和为 j 的子集
        vector<vector<int>> dp(n + 1, vector<int>(aim + 1, 0));  // 初始化动态规划数组
        
        // 遍历每一块石头
        for(int i = 1; i <= n; i++)
        {
            // 遍历可能的和 j
            for(int j = 0; j <= aim; j++)
            {
                dp[i][j] = dp[i - 1][j];  // 不选择当前石头，继承上一个状态
                
                // 如果当前和 j 大于等于当前石头的重量 stones[i - 1]，选择当前石头
                if(j >= stones[i - 1])
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - stones[i - 1]] + stones[i - 1]);
            }
        }
        
        // 最终结果：最小的差值为 sum - 2 * dp[n][aim]
        return sum - 2 * dp[n][aim];
    }
};

class Solution 
{
public:
    int lastStoneWeightII(vector<int>& stones) 
    {
        int n = stones.size();  // 获取石头的数量
        int sum = accumulate(stones.begin(), stones.end(), 0);  // 计算所有石头的总和
        int aim = sum / 2;  // 目标是找到一个和尽量接近 sum / 2 的子集
        
        // dp[j] 表示是否能选出和为 j 的子集
        vector<int> dp(aim + 1, 0);  // 初始化一维动态规划数组
        dp[0] = 1;  // 和为 0 时，选取 0 个元素的方式只有 1 种，即不选任何元素
        
        // 遍历每一块石头
        for(int i = 1; i <= n; i++)
        {
            // 从后往前更新 dp 数组，确保每个元素只用一次
            for(int j = aim; j >= stones[i - 1]; j--)
            {
                dp[j] = max(dp[j], dp[j - stones[i - 1]] + stones[i - 1]);  // 更新 dp[j]，增加当前石头的选择
            }
        }
        
        // 最终结果：最小的差值为 sum - 2 * dp[aim]
        return sum - 2 * dp[aim];
    }
};

完全背包问题的解决方法

问题： 给定多种物品，每种物品可以无限次地选择，背包的容量为V，求如何选择物品使得总价值最大，同时不超过背包容量。
解法思路： 完全背包问题允许每个物品被选多次，因此需要用动态规划来解决。我们可以使用一维数组来优化空间复杂度。
解法步骤：

  1. 初始化： 创建一个一维数组dp，大小为背包容量V+1，初始化所有元素为0，表示在容量0时的价值为0，其余容量初始化为0，后续处理中会被更新。
  2. 遍历物品： 对于每个物品，体积为v[i]，价值为w[i]。从背包容量V开始倒序遍历到物品体积v[i]。
  3. 更新状态： 对于每个容量j，检查是否可以放入当前物品（即j >= v[i]），如果可以，则更新dp[j]为dp[j - v[i]] + w[i]，即选择当前物品后的最大价值。
  4. 返回结果： 最终，dp[V]将存储背包容量为V时的最大价值。
  • 下面给出一个模板题，第二部分可以记忆将问题转化之后，直接套模板

【模板】完全背包

在这里插入图片描述
重点看第二部分，完全背包问题

#include <iostream>
#include <vector>
#include <string.h>
using namespace std;

const int N = 1010;  // 定义常量N，表示物品数量的最大值
int n, V;  // n表示物品的数量，V表示背包的容量
int v[N], w[N];  // v数组存储每个物品的体积，w数组存储每个物品的价值
int dp[N][N];  // dp二维数组，用来保存状态，dp[i][j]表示前i个物品，在容量为j时的最大价值

int main() 
{
   cin >> n >> V;  // 输入物品数量n和背包的容量V
   for(int i = 1; i <= n; i++)  // 输入每个物品的体积和价值
   {
        cin >> v[i] >> w[i];  // 输入物品i的体积v[i]和价值w[i]
   }

    // 第一部分：0-1背包的标准动态规划解法
    for(int i = 1; i <= n; i++)  // 遍历每个物品
    {
        for(int j = 0; j <= V; j++)  // 遍历每个容量
        {
            dp[i][j] = dp[i - 1][j];  // 不选第i个物品时，最大价值等于前i-1个物品在当前容量下的最大价值
            if(j >= v[i])  // 如果当前容量足够容纳第i个物品
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);  // 比较选和不选第i个物品后的最大价值
        }
    }

    // 输出第一次背包问题的结果，dp[n][V]即为前n个物品，容量V时的最大价值
    cout << dp[n][V] << endl;

    // 第二部分：带有限制条件的背包问题（物品是否能被选中的限制）————完全背包问题
    memset(dp, 0, sizeof(dp));  // 重置dp数组
    for(int j = 1; j <= V; j++) dp[0][j] = -1;  // 初始化dp[0][j]，表示没有物品时，容量j不可能选择任何物品，初始化为-1

    for(int i = 1; i <= n; i++)  // 遍历每个物品
    {
        for(int j = 0; j <= V; j++)  // 遍历每个容量
        {
            dp[i][j] = dp[i - 1][j];  // 不选第i个物品时，最大价值等于前i-1个物品在当前容量下的最大价值
            if(j >= v[i] && dp[i][j - v[i]] != -1)  // 如果当前容量足够容纳第i个物品并且dp[i][j - v[i]]不为-1，表示可以选择第i个物品
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);  // 比较选和不选第i个物品后的最大价值
        }
    }

    // 输出第二部分背包问题的结果，若dp[n][V]为-1，表示无法选择任何物品，则输出0
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
}

#include <iostream>
#include <vector>
#include <string.h>
using namespace std;

const int N = 1010;  // 定义常量N，表示物品数量的最大值
int n, V;  // n表示物品数量，V表示背包的容量
int v[N], w[N];  // v数组存储每个物品的体积，w数组存储每个物品的价值
int dp[N][N];  // dp二维数组，用来保存状态，dp[i][j]表示前i个物品，在容量为j时的最大价值

int main() 
{
   cin >> n >> V;  // 输入物品数量n和背包的容量V
   for(int i = 1; i <= n; i++)  // 输入每个物品的体积和价值
   {
        cin >> v[i] >> w[i];  // 输入物品i的体积v[i]和价值w[i]
   }

    // 第一部分：标准0-1背包的动态规划解法
    for(int i = 1; i <= n; i++)  // 遍历每个物品
    {
        for(int j = 0; j <= V; j++)  // 遍历每个容量
        {
            dp[i][j] = dp[i - 1][j];  // 不选第i个物品时，最大价值等于前i-1个物品在当前容量下的最大价值
            if(j >= v[i])  // 如果当前容量足够容纳第i个物品
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);  // 比较选和不选第i个物品后的最大价值
        }
    }

    // 输出第一次背包问题的结果，dp[n][V]即为前n个物品，容量V时的最大价值
    cout << dp[n][V] << endl;

    // 第二部分：带有限制条件的背包问题（物品是否能被选中的限制）
    memset(dp, 0, sizeof(dp));  // 重置dp数组
    for(int j = 1; j <= V; j++) dp[0][j] = -1;  // 初始化dp[0][j]，表示没有物品时，容量j不可能选择任何物品，初始化为-1

    for(int i = 1; i <= n; i++)  // 遍历每个物品
    {
        for(int j = 0; j <= V; j++)  // 遍历每个容量
        {
            dp[i][j] = dp[i - 1][j];  // 不选第i个物品时，最大价值等于前i-1个物品在当前容量下的最大价值
            if(j >= v[i] && dp[i][j - v[i]] != -1)  // 如果当前容量足够容纳第i个物品并且dp[i][j - v[i]]不为-1，表示可以选择第i个物品
                dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);  // 比较选和不选第i个物品后的最大价值
        }
    }

    // 输出第二部分背包问题的结果，若dp[n][V]为-1，表示无法选择任何物品，则输出0
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
}

零钱兑换

在这里插入图片描述

class Solution 
{
public:
    int coinChange(vector<int>& coins, int amount) 
    {
        int n = coins.size();  // 获取硬币种类的数量
        // 创建二维dp数组，dp[i][j]表示使用前i种硬币组成金额j的最小硬币数
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));

        // 初始化第一行，即没有任何硬币时，不可能组成任何金额（除了金额为0时为0）
        for(int j = 1; j <= amount; j++) 
            dp[0][j] = 0x3f3f3f3f;  // 0x3f3f3f3f是一个很大的数，表示无法达成目标金额

        // 填充dp表
        for(int i = 1; i <= n; i++)  // 遍历每种硬币
        {
            for(int j = 0; j <= amount; j++)  // 遍历每个金额
            {
                // 先不使用当前硬币，继承前一种硬币的结果
                dp[i][j] = dp[i - 1][j];
                
                // 如果当前金额j大于等于当前硬币的面额，则可以考虑使用当前硬币
                if(j >= coins[i - 1])
                    dp[i][j] = min(dp[i][j], dp[i][j - coins[i - 1]] + 1);  // 更新dp[i][j]为使用当前硬币后的最小硬币数
            }
        }

        // 如果最后的结果还是很大的数，表示无法组成目标金额，返回-1
        return dp[n][amount] >= 0x3f3f3f3f ? -1 : dp[n][amount];
    }
};

class Solution 
{
public:
    int coinChange(vector<int>& coins, int amount) 
    {
        int n = coins.size();  // 获取硬币种类的数量
        // 创建一维dp数组，dp[j]表示组成金额j的最小硬币数，初始化为一个非常大的数，表示不能用硬币组合的金额
        vector<int> dp(amount + 1, 0x3f3f3f3f);
        dp[0] = 0;  // 用0个硬币组成金额0所需的硬币数为0

        // 遍历每一种硬币
        for(int i = 1; i <= n; i++)
        {
            // 对于每个硬币，尝试更新dp数组
            for(int j = coins[i - 1]; j <= amount; j++)  // 从当前硬币的面额开始更新dp数组
            {
                // 如果可以用当前硬币（面额为coins[i-1]）更新dp[j]，则更新dp[j]为最小的硬币数
                dp[j] = min(dp[j], dp[j - coins[i - 1]] + 1);
            }
        }

        // 最后判断dp[amount]的值，如果它仍然是初始化的大数，表示不能用硬币组合成该金额，返回-1；否则返回最小硬币数
        return dp[amount] >= 0x3f3f3f3f ? -1 : dp[amount];
    }
};

零钱兑换||

在这里插入图片描述

class Solution 
{
public:
    int change(int amount, vector<int>& coins)
    {
        int n = coins.size();  // 获取硬币种类的数量
        vector<unsigned long long> dp(amount + 1);  // dp[j]表示组成金额j的不同组合数
        dp[0] = 1;  // 用0个硬币组成金额0的组合方式数为1

        // 遍历每种硬币
        for(int i = 1; i <= n; i++)
        {
            // 对于每个硬币，尝试更新dp数组，遍历所有金额
            for(int j = coins[i - 1]; j <= amount; j++)  // 从当前硬币的面额开始更新dp数组
            {
                dp[j] = dp[j] + dp[j - coins[i - 1]];  // 更新dp[j]为包含当前硬币后的组合数
            }
        }

        // 返回组成amount的不同组合方式数
        return dp[amount];
    }
};

完全平方数

class Solution 
{
public:
    int numSquares(int n) 
    {
        // 计算小于等于n的完全平方数的数量
        int m = sqrt(n);  
        // 创建dp数组，dp[i][j]表示前i个完全平方数组成金额j的最小平方数个数
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));

        // 初始化dp[0][j]，表示没有完全平方数时无法组成金额j
        for(int j = 1; j <= n; j++) dp[0][j] = 0x3f3f3f3f;  // 0x3f3f3f3f是一个很大的数，表示无法组成金额j

        // 填充dp数组
        for(int i = 1; i <= m; i++)  // 遍历每个小于等于n的完全平方数（i^2）
        {
            for(int j = 0; j <= n; j++)  // 遍历每个金额j
            {
                // 默认不使用当前完全平方数i^2的情况，继承上一个完全平方数的结果
                dp[i][j] = dp[i - 1][j];
                
                // 如果当前金额j大于等于i^2（即当前完全平方数），则可以尝试使用该完全平方数
                if(j >= i * i)
                    dp[i][j] = min(dp[i][j], dp[i][j - i * i] + 1);  // 更新dp[i][j]为最小的平方数个数
            }
        }

        // 返回组成n的最小完全平方数个数
        return dp[m][n];
    }
};

class Solution 
{
public:
    // numSquares方法，返回n可以表示为最少的完全平方数之和
    int numSquares(int n) 
    {
        // 计算小于等于n的完全平方数的数量
        int m = sqrt(n);  
        // 创建dp数组，dp[j]表示金额j的最小完全平方数个数
        vector<int> dp(n + 1);
        
        // 初始化dp数组，将每个金额的默认值设为一个较大的数，表示无法达到的状态
        for(int j = 1; j <= n; j++) 
            dp[j] = 0x3f3f3f3f;  // 0x3f3f3f3f 是一个大数，表示不可能组成该金额

        // 设置dp[0]为0，因为金额为0时，不需要任何完全平方数
        dp[0] = 0;

        // 遍历每个可能的完全平方数 i^2
        for(int i = 1; i <= m; i++)  // i从1到sqrt(n)
        {
            // 遍历每个目标金额 j
            for(int j = i * i; j <= n; j++)  // 从i^2开始更新dp数组
            {
                // 对于每个金额 j，尝试使用当前平方数 i^2 来更新最小平方数个数
                dp[j] = min(dp[j], dp[j - i * i] + 1);
            }
        }
        
        // 最终dp[n]存储了n的最小完全平方数个数，返回该值
        return dp[n];
    }
};
01背包问题优化
kupePoem的专栏
05-02 361
目录 一、题目描述 二、总体思路 三、优化思路 四、代码 一、题目描述 有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 为方便讲解和理解，下面讲述的例子均先用具体的数字代入，即：eg：number＝4，capacity＝8 二、总体思路 根据动态规划原理首先要找出状态转移方程。 i,前i件物品 j，背包容量 w[i],第i件物品重量 v[i],第i件物品价值 f[...
算法讲解之Dynamic Programing —— 背包DP [资源分配问题]
skysys的研究小屋
08-20 2999
说到动态规划算法里面的背包DP，有个东西是必看的。这里给出资源地址《背包九讲》http://download.youkuaiyun.com/detail/qq_33583069/9572174 然后这里还有份雅礼中学的课件 资源背包动态规划 - 下载频道 - youkuaiyun.com http://download.youkuaiyun.com/detail/qq_33583069/9606455 好，那开始我们的讲
01背包及其优化
weixin_44856457的博客
07-18 358
简小胡的背包 描述 给定N个物品,每个物品有一个重量W和一个价值V.你有一个能装M重量的背包.问怎么装使得所装价值最大.每个物品只有一个 输入 输入的第一行包含两个整数n, m，分别表示物品的个数和背包能装重量。 以后n行每行两个数Wi和Vi,表示物品的重量和价值 输出 输出1行，包含一个整数，表示最大价值。 第一种：二维数组的方法；就是用二重循环，一个个填进去； 思路： dp[k][c]=max(dp[k-1][c],dp[k-1][c-a[k]]+p[k]); #include<bits/std
01 背包优化
Creek Shi
09-09 1698
http://blog.youkuaiyun.com/scorpiocj/article/details/6415750 这两天做了下01背包的题，简单的总结下 首先，对于最基本的01背包问题，转移方程为dp[i][j]=max{dp[i-1][j],dp[i-1][j-cost[i]]+w[i]} 表示考虑第i件物品，容量为j时，有两种策略，第一种是不选该物品，第二种为选择该物
01背包（优化）
weixin_46097862的博客
07-04 257
01背包（优化） 题目 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 输出范围 0<N,V≤1000 0<vi,wi≤1000 输入
01背包 空间优化
骑鱼的喵喵的博客
02-20 252
01背包 空间优化O(N)版本  #include&lt;stdio.h&gt; #include&lt;algorithm&gt; #define INF 0x7fffffff using namespace std; struct coin { int v; int w; }list[505]; int dp[10005]; int main() { int e,f; while...
动态规划之背包问题——完全背包
小朱小朱绝不认输的博客
11-25 8361
文章目录一、完全背包问题二、完全背包遍历顺序三、leetcode例题讲解完全背包问题518. 零钱兑换 II377. 组合总和 Ⅳ322. 零钱兑换279. 完全平方数139. 单词拆分四、完全背包问题总结1. 动规五步分析法2. 背包递推公式3. 遍历顺序 前面整理了01背包，在leetcode题库中主要就是01背包和完全背包问题，所以在这里整理一下完全背包的知识点。 一、完全背包问题 有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都
夜深人静写算法（十七）- 分组背包
热门推荐
英雄哪里出来
01-21 4万+
互相冲突的背包——分组背包
算法萌新如何学好动态规划（三）
lucius-liu.cn
12-05 398
本文是「动态规划」系列文章的第三篇，作为「动态规划（二）- 线性 DP」的一个延伸，将主要聚焦于动态规划经典模型 —— 背包问题的讲解。 背包问题属于线性 DP 模型，之所以单独拎出来讲，主要是因为该问题信息量大且十分重要，属于面试中常考且必会的知识，因此我们将其放在本系列的第三篇进行介绍。
浅谈背包问题
m0_58178876的博客
04-26 1498
算法课的小作业，写了挺多就发掉吧，应该写的挺详细的（。 浅谈背包问题 定义：背包问题是运筹学中的一个经典的优化难题，是一个 NP-完全问题，但其有 着广泛的实际应用背景，是从生活中一个常见的问题出发展开的： 一个背包，和很多件物品，要在背包中放一些物品，以达到一定的目标。 (摘自《2008年国家集训队论文——浅谈几类背包问题（徐持衡）》) 0-1背包 0-1 背包问题：给定 n 件物品和一个背包。物品 i 的价值是 Wi ，其体积为 Vi，背包 的容量为 C。可以任意选择装入背包中的物品，求装..
01背包空间优化
愿岁月如歌
05-17 329
for (int i = 1; i <= n; i++) { for (int j = v; j >= 0; j--) { dp[j] = max(dp[j], dp[j - c[i]] + w[i]); } } 在关于二层循环的方向问题上我之前不是很清楚，主要解释一下这里。
01背包问题的算法优化
weixin_35750747的博客
02-17 560
01背包问题是一个经典的动态规划问题，旨在寻找一组物品，使得在满足限制条件(背包容量)的情况下，其总价值最大。 以下是几种算法优化方法： 状态压缩优化：在某些情况下，可以使用二进制数来表示当前状态，从而减少空间复杂度，提高程序效率。 二进制优化：对于某些数据特征较明显的问题，可以使用二进制数位运算的方法进行优化，进一步提高程序效率。 贪心算法优化：对于某些特殊的背包问题，可以采用贪心算法进行...
【基础】01背包优化及应用。
Timothy023的博客
03-21 417
如果想了解更多内容，欢迎关注我的微信公众号：信息学竞赛从入门到巅峰。 上期我们介绍了01背包问题的问题模型和解决方法，今天我们来讲解一下01背包算法在空间上的优化方法。 先贴上代码： for (int i = 1; i <= N; ++i) for (int j = 0; j <= V; ++j) if (j >= c[i]) ...
01背包问题及空间优化
yuweilong000的专栏
11-20 1002
一、题目描述： 有n件物品，每件物品占用的空间为w[i], 价值为p[i]。 有容量为 V 的背包。求在容量允许的范围下，背包装入物品的最大价值。 用dp[i][v] 表示 用剩余容量为v的背包，来装前i件物品，可以达到的最大价值。 那么 dp[i][0] = 0; 在当前为i，v的情况下，考察第i件物品。有两种情况。 1、如果i物品的体积大于v，根本装不下了。没得选，
01背包优化---java知识
m0_55486529的博客
03-29 941
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、为什么可以用一维数组实现呢？二、使用步骤1.引入库2.读入数据总结 前言 01背包正常解法dp数组为二维数组，优化可以使用一维数组倒推进行实现。 一、为什么可以用一维数组实现呢？ 求解第i行时，只需要第i-1行的结果，前面的结果已经没用了。求解c[i][i]时，只需要上一行j列或上一行j-w[i]列的结果。是否可以进行空间优化? 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np imp.
C++深度解析：动态规划求解01背包问题方法
01背包问题是经典的动态规划问题之一。在该问题中，背包有一定的承重限制，而物品的重量和价值是已知的，但每个物品只能选择放入或不放入背包中，不能将物品分割成更小的部分。目标是确定哪些物品应该被放入背包以...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值