动态规划——背包问题

最新推荐文章于 2026-06-22 19:04:06 发布
原创 最新推荐文章于 2026-06-22 19:04:06 发布 · 207 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#动态规划 #算法

概述

背包问题简而言之：你有一个背包 这个背包有一定的容积 要装入物品进去 不同物品体积不同 价值不同

背包的情况有两种 ：01背包就是每种物品只有一个选了之后就是1不选就是0 完全背包就是每种物品个数可能有多个

装入的情况也有两种：恰好将背包装满的最大物品价值 背包可以不装满的最大价值

示例题目：https://www.nowcoder.com/share/jump/3925989451770378237514

先研究第一种情况 也就是不需要装满

很明显 物品的价值和体积分别要用一个一维数组记录 w、v

若是定义dp[i] 从前i个物品中选择 此时的最大价值 这样是不行的 因为没有东西表示你的背包容积 不知道背包容积去选择物品肯定不行

所以定义dp[i][j] 从前i个物品中选择 并且选择的物品的总体积不超过j 此时的最大价值 现在看能不能推导状态转移方程 

i位置物品可以选也可以不选 不选 那么dp[i][j] = dp[i-1][j] 选那么dp[i][j] = w[i] + dp[i-1][j-v[i]] 因为选择了i 那么前面的方程容积肯定不能超过j-v[i] 但是j-v[i] 可能小于0 那么就在选择i物品这种情况之前判断一下j-v[i] >= 0 只有条件满足才可以选 最终dp[i][j] 是这两者之间的最大值

初始化 因为dp存在i-1 所以w、v最好也多开一个空间 让物品的下标从1开始标号 dp也多开一行一列 dp[0][0] = 0 因为其意思为从前0个物品中选 总体积不超过0的最大价值 价值就是0 第一行后面的位置 表示从前0个物品中选总体积不超过j 价值肯定也是0 因为选不到 第一列其他位置 物品存在 但是体积不可能为0 所以价值也是0

返回值返回dp[n][V] V表示背包的容积

第二种情况 背包恰好装满

相比于第一种情况只需要改动一部分即可

状态表示 定义dp[i][j] 从前i个物品中选择 并且选择的物品的总体积恰好为j 此时的最大价值

状态转移方程 这里有一个重点区别 若是选不到体积恰好为j的dp[i][j]应该填什么 显然这种情况是一种不可能的情况 也就是错误情况 这里用-1表示 -1表示错误 。若是不选i位置dp[i][j] = dp[i-1][j] 此时若是 dp[i-1][j] 为-1 也不影响 因为前面选不到体积恰好为 j 的 那么不选 i 之后的 dp[i][j] 肯定也选不到体积恰好为j的 所以也填入-1 若是选 i位置 区别于不需要将背包填满的情况 只需要添加一下条件 原本是dp[i][j] = w[i] + dp[i-1][j-v[i]] 但是dp[i-1][j-v[i]] 可能为-1 若是让-1进来这个方程 物品的价值就被改变了 很显然不合逻辑 并且从状态表示出发 若是 前面dp[i-1][j-v[i]]==-1 这里选了i体积也不能凑成为j的 因此方程不能为dp[i][j] = w[i] + dp[i-1][j-v[i]] 所以想要方程为这个 要加一个条件 就是 dp[i-1][j-v[i]] != -1 从这个两个中选最大值

初始化 dp[0][0] = 0 第一行后面的从前0个物品中选 全部选不到容积恰好为j的 都填-1 第一列下面的 为全部为0

返回值 返回dp[n][V]

代码：

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

int main() 
{
    int n, V;
    cin >> n >> V;
    vector<int> v(n+1, 0), w(n+1, 0);
    vector<vector<int>> dp(n+1, vector<int>(V+1, 0));
    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] >= 0) dp[i][j] = max(dp[i][j], w[i] + dp[i-1][j-v[i]]);
        }
    }
    cout << dp[n][V] << endl;

    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] >= 0 && dp[i-1][j-v[i]] != -1) dp[i][j] = max(dp[i][j], w[i] + dp[i-1][j-v[i]]);
        }
    }
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
    return 0;
}

空间优化 滚动数组

原dp是二维的 但是每次填表需要的两个位置在同一行 那么可以这样优化空间 开两个一维数组 大小为V+1 第一个数组记录i-1那一行 也就是此时填表需要的一行 第二个数组表示当前行 填完当前行之后将第一个数组赋值为当前数组 那么填后面的dp时 填到第二个数组里面 参照第一个数组 这样向下滚动的过程就是滚动数组 完成了空间的优化 这是最基本的滚动数组

本题用另一种更佳的方式优化 填当前位置的时候 其实只需要两个位置 i-1行的两个位置 那么可以只开一个V+1的一维数组 这个数组记录的是i-1行的信息 此时为i行开始填表 从后往前填 这样可以保证i-1行的我们需要的两个位置没有被覆盖 也就是确保i行的内容是正确的 这样完成空间优化

在上述代码上的修改实际上就是要消去dp表的行保存列 并且改一下填表顺序即可

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

int main() 
{
    int n, V;
    cin >> n >> V;
    vector<int> v(n+1, 0), w(n+1, 0);
    vector<int> dp(V+1, 0);
    for (int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i++)
    {
        for (int j = V; j >= 1; j--)
        {
            // dp[j] = dp[j]; // 去掉行之后就是这样的 那可以直接省略
            if (j - v[i] >= 0) dp[j] = max(dp[j], w[i] + dp[j-v[i]]);
        }
    }
    cout << dp[V] << endl;

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

题目

416. 分割等和子集 - 力扣（LeetCode）

class Solution 
{
public:
    bool canPartition(vector<int>& nums) 
    {
        int n = nums.size();
        int sum = 0;
        for (auto& num : nums) sum += num;
        if (sum % 2 != 0) return false;


        vector<vector<bool>> dp(n+1, vector<bool>(sum/2+1, false));
        for (int i = 1; i <= n; i++) dp[i][0] = true;

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= sum / 2; j++)
            {
                dp[i][j] = dp[i-1][j];
                if (j - nums[i-1] >= 0) dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i-1]];
            }
        }
        return dp[n][sum/2];
    }
};

// 先分析 我们只需要从数组中选则一部分元素 使之和为sum / 2 sum为nums中元素总和
// 那么每个元素就面临着选与不选的问题 从此我们想到01背包 这是物品没有价值的01背包 只需要使体积为sum / 2

// 状态表示
// 定义dp[i][j] : 从前i个元素中选 看能否等于j dp中存的值为true或者false

// 状态转移方程
// 不选i位置 为dp[i-1][j] 选i位置 为dp[i-1][j-nums[i]] 当然要有条件限制 就是j - nums[i] >= 0

// 初始化 
// dp表多开一行一列 此时要注意下标的映射关系
// dp[0][0] = true 第一行后面的全为false 因为不可能从0中选出不为0的数 第一列下面全为true 每一次都不选即可

// 返回值 返回dp[n][sum/2] 要注意只有sum为偶数才能这样动态规划 为奇数一定不能分割 直接返回false

// 空间优化
class Solution 
{
public:
    bool canPartition(vector<int>& nums) 
    {
        int n = nums.size();
        int sum = 0;
        for (auto& num : nums) sum += num;
        if (sum % 2 != 0) return false;


        vector<bool> dp(sum / 2 + 1, false);
        dp[0] = true;

        for (int i = 1; i <= n; i++)
        {
            for (int j = sum / 2; j >= 1; j--)
            {
                dp[j] = dp[j];
                if (j - nums[i-1] >= 0) dp[j] = dp[j] || dp[j-nums[i-1]];
            }
        }
        return dp[sum/2];
    }
};

494. 目标和 - 力扣（LeetCode）

// class Solution
// {
// public:
//     int findTargetSumWays(vector<int>& nums, int target)
//     {
//         int sum = 0;
//         for (auto& i : nums)
//             sum += i;
//         int a = (sum + target) / 2;
//         if ((sum + target) % 2 || a < 0)
//             return 0;

//         int n = nums.size();
//         vector<vector<int>> dp(n+1, vector<int>(a+1, 0));
//         dp[0][0] = 1;
//         for (int i = 1; i <= n; i++)
//         {
//             for (int j = 0; j <= a; j++) // j从0开始因为没有初始化第一列
//             {
//                 dp[i][j] = dp[i-1][j];
//                 if (j - nums[i-1] >= 0)
//                     dp[i][j] += dp[i-1][j - nums[i-1]];
//             }
//         }
//         return dp[n][a];
//     }
// };
// 空间优化
class Solution
{
public:
    int findTargetSumWays(vector<int>& nums, int target)
    {
        int sum = 0;
        for (auto& i : nums)
            sum += i;
        int a = (sum + target) / 2;
        if ((sum + target) % 2 || a < 0)
            return 0;

        int n = nums.size();
        vector<int> dp(a+1);
        dp[0] = 1;
        for (int i = 1; i <= n; i++)
        {
            for (int j = a; j >= 0; j--) // j从0开始因为没有初始化第一列
            {
                if (j - nums[i-1] >= 0)
                    dp[j] += dp[j - nums[i-1]];
            }
        }
        return dp[a];
    }
};
// 转换：将nums中的数分为正负两个部分（a、b表示正负两部分绝对值的和）并且a-b=target（按照提议反推，假设a、b就是我们最终分出来的正负部分）
// 又因为a+b=sum，那么消去b，a = （sum + target）/ 2

// 这样一来就是01背包了，意思就是选择物品，使之总体积恰好为一个数
// 定义dp[i][j] 从前i个物品中挑选，体积恰好我j的选法

// 状态转移方程：
// 不选nums[i]，那么dp[i][j]有dp[i-1][j]种选法；选nums[i]，那么dp[i][j]有dp[i-1][j-nums[i]]种选法（要判断j-nums[i] >= 0）
// 最终dp[i][j]为两者相加

// 初始化
// 多开一行一列
// 第一行除了dp[0][0]全部初始化为0，dp[0][0]=1
// 第一列除了dp[0][0]，看是什么情况：因为nums[i]可能为0，那么从前i个位置选体积为0就可能出现多种情况了，比如dp[1][0]，但是nums[1]=0，后面也可能会出现，这样一来不能简单地初始化0或者1了。事实上这一行不用初始化，通过观察，选择这个位置要先判断j-nums[i] >= 0，而j为0，nums[i]>=0，只有nums[i]==0的时候第一列才会填表，但是现在使用的上一列的值（j-nums[i] = 0），没使用左上角，所以不用初始化

// 返回值
// dp[n][a]

1046. 最后一块石头的重量 - 力扣（LeetCode）

class Solution
{
public:
    int lastStoneWeightII(vector<int>& stones)
    {
        int n = stones.size(), sum = 0;
        for (int i = 0; i < n; i++)
            sum += stones[i];
        int target = sum / 2;
        vector<int> dp(target + 1, 0);
        for (int i = 1; i <= n; i++)
        {
            for (int j = target; j >= 1; j--)
            {
                if (j - stones[i - 1] >= 0)
                    dp[j] = max(dp[j], dp[j - stones[i - 1]] + stones[i - 1]);
            }
        }
        return sum - 2 * dp[target];
    }
};

// 问题转换：
// 本质上就是给数字前面加上+、-号然后相加求出最小和，和目标和类似
// 将整个数组中数字分为正负两部分，求出两者绝对值的最小差值
// 一个数字只有将其分为接近这个数字一半的两部分，这两部分的差值才是最小的

// 01背包
// 背包容积sum/2，物品体积、价值都是数字数值

完全背包_牛客题霸_牛客网

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

int main()
{
    int n, V;
    cin >> n >> V;
    vector<int> v(n), w(n);
    for (int i = 0; i < n; i++)
    {
        cin >> v[i] >> w[i];
    }
    vector<vector<int>> dp(n + 1, vector<int>(V + 1, 0));
    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 - 1] >= 0)
                dp[i][j] = max(dp[i][j], dp[i][j - v[i - 1]] + w[i - 1]);
        }
    }
    cout << dp[n][V] << endl;
    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 - 1] >= 0 && dp[i][j - v[i - 1]] != -1)
                dp[i][j] = max(dp[i][j], dp[i][j - v[i - 1]] + w[i - 1]);
        }
    }
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
    return 0;
}

// 第一问
// 状态表示
// 定义dp[i][j]:从前i个物品中挑选，总体积不超过j的最大价值

// 状态转移方程
// dp[i][j] : 不选i位置为dp[i-1][j], 选i位置可以选多个i即max(dp[i-1][j-v[i]]+w[i], dp[i-1][j-2*v[i]]+2*w[i]......, dp[i-1][j-k*v[i]]+k*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-1][j-k*v[i]]+k*w[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-1][j-x*v[i]]+(x-1)*w[i]);
// 观察第一个公式的右边部分除了第一个的后面部分，和下面公式的右边部分就差一个w[i]
// 所以dp[i][j] = max(dp[i-1][j], dp[i][j-v[i]]+w[i]);

// 初始化
// 多开一行一列，第一行全部为0，第一列全部为0

// 填表顺序
// 只能从上往下，从左往右，因为dp[i][j-v[i]]+w[i]需要用到同行中前面的值

// 返回值
// dp[n][V]

// 第二问

// 状态标识
// 定义dp[i][j]:从前i个物品中挑选，总体积恰好为j的最大价值

// 状态转移方程
// dp[i][j] = max(dp[i-1][j], dp[i][j-v[i]]+w[i]);
// 但是要注意一个点，就是dp[i][j-v[i]]可能存在这种情况，就是不能恰好填满，这个时候设置为-1，所以除了要判断j-v[i]>=0，还需要dp[i][j-v[i]]!=-1

// 初始化
// 多开一行一列，第一行第一个为0，剩下为-1（从前0个物品中选，总体积不可能恰好为一个非0的），第一列全部为0

// 返回值
// 要判断是不是-1

LCR 103. 零钱兑换 - 力扣（LeetCode）

// class Solution
// {
// public:
//     const int INF = 0x3f3f3f3f;
//     int coinChange(vector<int>& coins, int amount) 
//     {
//         int n = coins.size();
//         vector<vector<int>> dp(n+1, vector<int>(amount+1, INF));
//         dp[0][0] = 0;
//         for (int i = 1; i <= n; i++)
//             dp[i][0] = 0;
//         for (int i = 1; i <= n; i++)
//         {
//             for (int j = 1; j <= amount; j++)
//             {
//                 dp[i][j] = dp[i-1][j];
//                 if (j - coins[i-1] >= 0 && dp[i][j - coins[i-1]] < INF)
//                     dp[i][j] = min(dp[i][j], dp[i][j - coins[i-1]] + 1);
//             }
//         }
//         return dp[n][amount] >= INF ? -1 : dp[n][amount];
//     }
// };
// 空间优化
class Solution
{
public:
    const int INF = 0x3f3f3f3f;
    int coinChange(vector<int>& coins, int amount)
    {
        int n = coins.size();
        vector<int> dp(amount + 1, INF);
        dp[0] = 0;

        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= amount; j++)
            {
                if (j - coins[i - 1] >= 0 && dp[j - coins[i - 1]] < INF)
                    dp[j] = min(dp[j], dp[j - coins[i - 1]] + 1);
            }
        }
        return dp[amount] >= INF ? -1 : dp[amount];
    }
};

// 看到无限想到完全背包

// 状态表示
// 定义dp[i][j]:从前i个硬币里面选，总金额恰好为j的最小硬币个数

// 状态转移方程
// 和完全背包模板一样
// dp[i][j] = min(dp[i-1][j], dp[i][j-coins[i]] + 1); （只有完全背包可以用这个数学规律）

// 初始化
// 多开一行一列，不可能的地方填0x3f3f3f3f（已经很大了）

// 返回值
// 先判断是否>=0x3f3f3f3f，大于则返回-1，否则返回dp[n][amount];

518. 零钱兑换 II - 力扣（LeetCode）

// class Solution 
// {
// public:
//     int change(int amount, vector<int>& coins) 
//     {
//         int n = coins.size();
//         vector<vector<unsigned int>> dp(n + 1, vector<unsigned int>(amount + 1, 0)); // 超出范围直接截断
//         for (int i = 1; i <= n; i++)
//             dp[i][0] = 1;
//         for (int i = 1; i <= n; i++)
//         {
//             for (int j = 1; j <= amount; j++)
//             {
//                 dp[i][j] = dp[i-1][j];
//                 if (j - coins[i-1] >= 0)
//                     dp[i][j] += dp[i][j - coins[i-1]];
//             }
//         }
//         return dp[n][amount];
//     }
// };

// 空间优化
class Solution
{
public:
    int change(int amount, vector<int>& coins)
    {
        int n = coins.size();
        vector<unsigned int> dp(amount + 1, 0); // 超出范围直接截断
        dp[0] = 1;
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= amount; j++)
            {
                dp[j] = dp[j];
                if (j - coins[i - 1] >= 0)
                    dp[j] += dp[j - coins[i - 1]];
            }
        }
        return dp[amount];
    }
};

// 组合有多少种？每一次选的硬币变换了都要加上这个选法的种类
// 选与不选都是选法，都要加上去

279. 完全平方数 - 力扣（LeetCode）

class Solution
{
public:
    const int INF = 0x3f3f3f3f;
    int numSquares(int n)
    {
        int m = sqrt(n);
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int j = 1; j <= n; j++)
            dp[0][j] = INF; // 因为是最少个数，所以将不可能的选法设置为大的数
        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                dp[i][j] = dp[i - 1][j];
                if (j - i * i >= 0)
                {
                    dp[i][j] = min(dp[i][j], dp[i][j - i * i] + 1);
                }
            }
        }
        return dp[m][n];
    }
};

// 就相当于从1到根号n的数种找一些数的平方和恰好等于n，求选的数的最少个数
// 完全背包

// dp[i][j] = (dp[i-1][j], dp[i-1][j-i^2]+1, dp[i-1][j-2*i^2]+2........, dp[i-1][j-n*i^2]+n);
// dp[i][j-i^2] = (dp[i-1][j-i^2], dp[i-1][j-2*i^2]+1, dp[i-1][j-3*i^2]+2........, dp[i-1][j-n*i^2]+n);

474. 一和零 - 力扣（LeetCode）

// class Solution 
// {
// public:
//     int findMaxForm(vector<string>& strs, int m, int n) 
//     {
//         int len = strs.size();
//         vector<pair<int, int>> cnt01(len);
//         // 计算每个字符串的0、1个数
//         for (int i = 0; i < len; i++)
//         {
//             int cnt0 = 0, cnt1 = 0;
//             for (auto& c : strs[i])
//             {
//                 if (c == '0') cnt0++;
//                 else cnt1++;
//             }
//             cnt01[i] = make_pair(cnt0, cnt1);
//         }
//         vector<vector<vector<int>>> dp(len + 1, vector<vector<int>>(m + 1, vector<int>(n + 1, 0)));
//         for (int i = 1; i <= len; i++)
//         {
//             for (int j = 0; j <= m; j++)
//             {
//                 for (int k = 0; k <= n; k++)
//                 {
//                     dp[i][j][k] = dp[i - 1][j][k];
//                     int a = cnt01[i - 1].first, b = cnt01[i - 1].second;
//                     if (j - a >= 0 && k - b >= 0)
//                         dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - a][k - b] + 1);
//                 }
//             }
//         }    
//         return dp[len][m][n];
//     }
// };

// 实际上也是完全背包问题，只不过限定条件从一维变为了二维（可以理解为一维只需要保证体积不超，而现在重量也要保证）：从数组中选一些字符串，这些字符串0、1的数量和不超过m、n

// 状态表示
// 定义dp[i][j][k]:从前i个字符串中选，0总和不超过j，1总和不超过k的选取字符串最大个数

// 状态转移方程
// 不选i位置，那么dp[i][j][k] = dp[i-1][j][k];
// 选i位置（a、b分别表示i位置字符串0、1的个数），那么dp[i][j][k] = dp[i-1][j-a][k-b] + 1（是最大个数，因此选一个是加1），但是需要保证下标合法
// 最终选两者最大值
// a、b可以提前计算

// 初始化
// 多开一个位置，全部初始化为0即可，从前0个中选使之0、1数量不超过j，k的最大长度明显选不到，所以初始化为0；从前i个中选，使之0，1数量不超过0，0因为没有空串，所以不可能选到，初始化为0即可，dp[0][0][0]这个位置显而易见是0

// 返回值dp[len][m][n]

// 空间优化需要从后往前，避免需要的数据被覆盖

class Solution 
{
public:
    int findMaxForm(vector<string>& strs, int m, int n) 
    {
        int len = strs.size();
        vector<pair<int, int>> cnt01(len);
        // 计算每个字符串的0、1个数
        for (int i = 0; i < len; i++)
        {
            int cnt0 = 0, cnt1 = 0;
            for (auto& c : strs[i])
            {
                if (c == '0') cnt0++;
                else cnt1++;
            }
            cnt01[i] = make_pair(cnt0, cnt1);
        }
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int i = 1; i <= len; i++)
        {
            for (int j = m; j >= 0; j--)
            {
                for (int k = n; k >= 0; k--)
                {
                    int a = cnt01[i - 1].first, b = cnt01[i - 1].second;
                    if (j - a >= 0 && k - b >= 0)
                        dp[j][k] = max(dp[j][k], dp[j - a][k - b] + 1);
                }
            }
        }    
        return dp[m][n];
    }
};

879. 盈利计划 - 力扣（LeetCode）

class Solution 
{
public:
    const int mode = 1e9 + 7; 
    int profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) 
    {
        int m = group.size();
        vector<vector<vector<int>>> dp(m + 1, vector<vector<int>>(n + 1, vector<int>(minProfit + 1, 0)));
        for (int j = 0; j <= n; j++)
            dp[0][j][0] = 1;
        for (int i = 1; i <= m; i++)
        {
            for (int j = 0; j <= n; j++)
            {
                for (int k = 0; k <= minProfit; k++)
                {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if (j - group[i - 1] >= 0)
                        dp[i][j][k] += dp[i - 1][j - group[i - 1]][max(0, k - profit[i - 1])];
                    dp[i][j][k] %= mode;
                }
            }
        }
        return dp[m][n][minProfit];
    }
};

// 二维01背包问题

// 状态表示
// 选任务，人数不超过n，并且利润超过minProfit的所有选法

// 状态转移方程
// 定义dp[i][j][k]: 从前i个任务中选，人数不超过j，利润超过k的选法
// 不选i位置任务，则dp[i][j][k] = dp[i-1][j][k]
// 选i位置任务，dp[i][j][k] += dp[i-1][j-group[i]][k-profit[i]]
// 其中j-group[i]不能小于0，小于0说明人数超过限制
// k - profit[i]可以小于0，小于0说明从前i-1任务中选利润超过负数的，显然随便选，但是下标可能越界因此要这样写max(0, k-profit[i])，
// 因为从前i-1个中选利润大于0的也是随便选

// 初始化
// 每一维多开一行
// dp[0][j][0] = 1，无论j是几都只有一种选法，就是不选

39. 组合总和 - 力扣（LeetCode）

class Solution 
{
public:
    int combinationSum4(vector<int>& nums, int target) 
    {
        int n =nums.size();
        vector<unsigned int> dp(target + 1);
        dp[0] = 1;
        for (int i = 1; i <= target; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (i - nums[j] >= 0)
                    dp[i] += dp[i - nums[j]];
            }
        }
        return dp[target];
    }
};

// 似包非包
// 看似是完全背包问题，但是这题每一种选法可以排列，完全背包解决不了
// 需要找重复子问题（多刷题总结经验）

// 状态表示
// dp[i]：凑成数i的组合总数

// 状态转移方程
// dp[i] += dp[i - nums[j]]

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

// 返回值
// dp[target]

96. 不同的二叉搜索树 - 力扣（LeetCode）

class Solution 
{
public:
    int numTrees(int n) 
    {
        vector<int> dp(n + 1);
        dp[0] = 1;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= i; j++)
                dp[i] += dp[i - j] * dp[j - 1];
        return dp[n];
    }
};

// 需要找重复子问题（多刷题总结经验）

// 状态表示
// dp[i]:以i为根节点能组成几种不同的二叉搜索树
// 选定一个数i（1~n）作为根节点，找以这个值为根节点的二叉搜素树，那么左、右子树的二叉搜索树个数就是重复子问题

// 状态转移方程
// 以i为根节点，左子树的根节点变化在1~i-1之间，右子树根节点变化在i+1~n之间

动态规划之背包问题
rain_lin2000的博客
01-22 1497
0-1背包问题；完全背包问题；多重背包问题；动态规划；
动态规划——分组背包问题
yourgrandfather_的博客
12-22 1909
聪明人都会点进来学习！！动态规划看这一篇就够了！！!本文详细讲解了动态规划的核心思路（配有图片），还以经典问题——分组背包问题为例，先从基础解法开始讲解思路，再一步步优化，带有完整代码（有详细注释），对于难以理解的地方还会举例讲解，还会和01背包问题对比思考，赶紧点进来学习吧！！！
动态规划——01背包问题
热门推荐
Wu_L7的博客
04-22 3万+
面向小白的动态规划之01背包问题的详细讲解
【动态规划】01背包问题
一个专注于客户端开发的技术er，不定期更新Android，Flutter，HormonyOS等方向的使用心得和感悟
05-16 6700
【动态规划】01背包问题
动态规划之背包问题（Java）
深耕Java后端领域，拆解算法核心思路，探索微服务搭建奥秘，沉淀专属技术笔记
05-12 463
本文介绍了动态规划中经典的背包问题，包括01背包、完全背包和多重背包三种类型。01背包每个物品只能选一次，采用倒序遍历背包容量；完全背包物品可无限选，采用正序遍历；多重背包物品有数量限制，在01背包基础上增加数量循环。文章通过Java代码示例展示了三种背包问题的解法，并解释了正序和倒序遍历的本质区别：倒序防止重复使用物品，正序允许重复使用。最后总结了三种背包问题的核心区别在于物品数量和遍历顺序的不同。
动态规划之背包问题（C语言）
一串代码的博客
08-24 1万+
动态规划 动态规划（英语：Dynamic programming，简称DP）是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题和最优子结构性质的问题 动态规划思想大致上为：若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 由于通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 3925
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 438
超详细的Floyd算法教程，一看就懂！
2026年第九届GXCPC广西大学生程序设计大赛（热身赛）题解
奇妙方程式的博客
06-15 269
题目来源：未知，可在评论区补充。
CodeQUEEN 2026 -qual- (AtCoder Beginner Contest 462)题解
Timmylyx0518的博客
06-20 259
第六次 AK，记录一下。
数据结构基础复习——排序算法的关键代码片段
最新发布
2301_80025611的博客
06-22 305
针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空或。
百度 C++/PHP 研发一二面：一面扫八股和算法，二面开始逼近 Redis、MySQL 和秒杀设计
TechPioneer_lp的博客
06-15 268
这篇百度C++/PHP研发面经展现了后端岗位的面试进阶路径：一面侧重算法、操作系统、网络等基础（如链表判环、HTTP协议），二面则深入Redis/MySQL底层、高并发设计（如秒杀系统）。面经揭示百度筛选标准：基础合格后，重点考察缓存/数据库系统理解、高并发设计能力。建议准备时：一面夯实算法和语言基础（C++关键字/多态），二面吃透Redis/MySQL原理，并构建系统设计思维。笔试不佳仍有面试机会，但二面才是真正的能力分水岭。
《LeetCode 200 FloodFill 岛屿数量DFS解法》
2601_95366422的博客
06-15 290
LeetCode200 岛屿数量
【STL】算法
呆瓜的博客
06-22 257
本文介绍了C++标准库算法的术语规范与基本要求。主要内容包括：1) 标准区间表示法如[A,B)及其遍历规则；2) 等值判断二元谓词的三项强制要求；3) 排序/堆算法中严格弱序的定义及合法谓词示例；4) 升序序列和大顶堆的具体判定标准；5) 算法头文件<algorithm>和<numeric>的功能划分。特别强调所有比较函数必须满足不修改参数、结果一致性和严格弱序等核心规范。
现代CAD几何内核中的求交算法——从曲线求交到曲面求交的原理与实现
m0_53082780的博客
06-21 218
无论是模型布尔运算、特征建模、曲面修剪、装配分析，还是数控加工中的刀具路径规划，其底层都离不开各种形式的几何求交。然而在工业级CAD内核中，由于大量采用NURBS曲线与曲面表示复杂几何对象，传统解析求解方法已经难以适用，取而代之的是基于参数空间、数值迭代以及拓扑重建的一整套工程化算法体系。本文从CAD几何内核的角度出发，系统介绍曲线求交、曲线曲面求交以及曲面曲面求交的数学本质和工程实现流程，并结合OpenCASCADE等主流CAD内核的实现思想，帮助读者建立完整的几何求交知识框架。
C语言学习笔记 - 55.流程控制9 - 选择5 - if...else if多分支语句
weixin_57913829的博客
06-17 321
本文介绍了C语言中if-elseif多分支语句的核心概念和应用。该语句专门用于处理多个互斥条件的选择问题，通过自上而下依次判断表达式，从多个分支中选择且仅执行一个语句块。文章详细阐述了语法格式、执行逻辑，并提供了成绩等级划分和一元二次方程求解两个典型示例。同时指出了常见错误，如条件判断顺序错误、单独的else语句等，并对比了if-elseif与嵌套if语句的优劣，强调前者在代码简洁性和可读性方面的优势。
[LC优选算法#7] 分治:快排&归并 | 库存管理 III | 排序数组 | 交易逆序对的总数
C++开发
06-22 199
本文介绍了两种经典的分治排序算法——快速排序和归并排序，并结合LeetCode题目展示了它们的应用。 快速排序部分： 通过库存管理III问题，展示了快速选择算法解决TopK问题的思路，时间复杂度O(N)。 使用随机选key和数组三块分区的方法实现快速排序变种。 归并排序部分： 以排序数组题目为例，展示了标准归并排序的实现，时间复杂度O(NlogN)。 重点分析了交易逆序对问题，提出利用归并排序过程中计算逆序对数量： 通过升序/降序版本归并排序统计逆序对巧妙利用已排序子数组的性质优化计算。
C语言学习笔记20260620-数字筛选算法：排除4的倍数与含4数字
2503_92342417的博客
06-20 642
本文介绍了C语言中处理数字筛选问题的三种方法，目标是排除1到n之间4的倍数和含数字4的数。方法一使用数学取模运算逐位检查；方法二通过封装函数提高代码模块化和可读性；方法三将数字转为字符串处理。三种方法各具特点：方法一基础但效率高，方法二可读性最佳，方法三适合复杂判断条件。文章建议根据实际需求选择合适方法，其中方法二的函数封装方式在算法竞赛中最具实用性。
LeetCode 3264.K次乘运算后的最终数组I
tus00000的博客
06-17 249
如果nums的大小为n，数组中最大值为U，multiplier为m，则此算法时间复杂度为O(nlognlog。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。输入：nums = [1,2], k = 3, multiplier = 4。1 次操作后 [2, 2, 3, 5, 6]2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]5 次操作后 [8, 4, 6, 5, 6]
滑动窗口最大值问题：单调队列的巧妙应用
纳兰青华的博客
06-16 348
本文介绍了使用单调队列高效解决滑动窗口最大值问题的方法。通过维护一个单调递减的双端队列存储元素索引，算法能在O(n)时间复杂度内找到每个窗口的最大值。关键步骤包括：1)维护队列单调性，移除小于新元素的队尾元素；2)检查队首元素是否超出窗口范围；3)当窗口形成时记录队首最大值。相比暴力解法的O(n×w)复杂度，这种优化方案显著提升了效率，特别适合处理大规模数据。文章结合示例详细演示了算法执行过程，并分析了复杂度，最后总结了单调队列在滑动窗口问题中的通用性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值