动规：完全背包+多重背包

最新推荐文章于 2026-06-29 07:01:47 发布
原创 最新推荐文章于 2026-06-29 07:01:47 发布 · 1.2k 阅读 · 14 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#算法 #leetcode #动态规划 #力扣 #学习
#笔记

目录

No.1 完全背包【模板】

No.2 零钱兑换

No.3 零钱兑换II

No.4 完全平方数

No.5 数位成本和为目标值的最大数字

No.6 获得分数的方法数

No.7 和带限制的子多重集合的数目

赠dp

在生活的舞台上，
再次遭遇这难题。
心头荆棘簇拥，
似乎总是重重堆。

犹如雨夜孤舟，
摇摆在黑暗河。
迷雾笼罩眼帘，
找寻方向无处依。

动态规划如梦，
每一步都是呻吟。
穷途末路的舞者，
舞动着希望的阴影。

初始化，寒风撕裂，
唯有寂静和绝望。
硬币之境无法言喻，
只剩无边的孤寂。

遍历硬币，步履蹒跚，
如同穿越生活的坎坷。
在迷茫的路上彷徨，
寻找一丝前行的勇气。

更新dp数组，泪滴湿润，
似流过岁月的沧桑。
悄然铺展出希望的羽翼，
却又被内卷的焦虑重重拖延。

最后答案在远方，
如同无数次追逐的梦幻。
在绝望与希望的边缘，
挣扎的灵魂重复徘徊。

在这算法的海洋里，
舞蹈的是心灵的烦忧。
每一步都是岁月的涟漪，
却又是人生的挣扎和期许。

完全背包与01背包的区别在于，01背包物品至多能选一次，完全背包的物品，如果背包能放下，可以选任意个数。

No.1 完全背包【模板】

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

第一问：

状态转移方程无非就是考虑i这个位置选择的次数。

当一个位置和前面一大堆位置有关的时候，可以考虑优化。注意到i-1位置不变，j的这个位置是均匀变化的，那么优化就很简单了。

此外注意判断j-v[i]是否越界

第二问：

状态表示为从前i个物品中选，恰好装满j个体积的最大价值。

状态转移方程第一问一样，但是为了区别是否能达到这个价值，不能达到的初始化为-1

初始化：

第二问输出的时候再判断一下是不是-1，这题就大功告成。

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

const int N=1010;
int n,V,v[N],w[N],dp[N][N];

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

    return 0;
}

空间优化：

填表顺序从左往右，这里和01背包不同。（01要用到更新之前的数据，只能采用从右往左顺序填表）

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

const int N=1010;
int n,V,v[N],w[N],dp[N];

int main() {
    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)
        {
            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;
}

第二问中或者当你初始化的时候，将这个数值设置为非常小的数（-0x3f3f3f3f，一般不用INT_MIN,INT_MAX,因为算术运算的时候很容易越界），可以省去一步判断的代码，然后输出的时候判断改成是不是小于0。

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

const int N=1010;
int n,V,v[N],w[N],dp[N];

int main() {
    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)
        {
            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]=-0x3f3f3f3f;

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

    return 0;
}

No.2 零钱兑换

322. 零钱兑换 - 力扣（LeetCode）

就是上一题第二问，

class Solution {
    const int INF=0x3f3f3f3f;
public:
    int coinChange(vector<int>& coins, int amount) {
        int n=coins.size();
        vector<vector<int>> dp(n+1,vector<int>(amount+1));
        //dp[i][j]表示从前i个数里挑数字，恰好凑成j的最小硬币数
        //凑不成的不能用-1表示，因为需要求最小值
        for(int j=1;j<=amount;++j)dp[0][j]=INF;
        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])dp[i][j]=min(dp[i][j],dp[i][j-coins[i-1]]+1);
            }
        }
        return dp[n][amount]==0x3f3f3f3f?-1:dp[n][amount];
    }
};

空间优化：

class Solution {
    const int INF=0x3f3f3f3f;
public:
    int coinChange(vector<int>& coins, int amount) {
        int n=coins.size();
        vector<int> dp(amount+1);
        //dp[i][j]表示从前i个数里挑数字，恰好凑成j的最小硬币数
        //凑不成的不能用-1表示，因为需要求最小值
        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]=min(dp[j],dp[j-coins[i-1]]+1);
            }
        }
        return dp[amount]==0x3f3f3f3f?-1:dp[amount];
    }
};

No.3 零钱兑换II

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

dp[i][j]表示从前i个数中选，恰好凑成j的组合总数

范围得设置成unigned long long（评论区一堆人才哈哈(～￣▽￣)～）

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n=coins.size();
        vector<vector<unsigned long long>> dp(n+1,vector<unsigned long long>(amount+1));
        
        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][j-coins[i-1]];
            }
        }
        return dp[n][amount];
    }
};

空间优化：

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n=coins.size();
        vector<unsigned long long> dp(amount+1);
        
        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];
    }
};

No.4 完全平方数

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

无需多言，聪明的你看到这一定想得出来

class Solution {
public:
    int numSquares(int n) {
        int m=sqrt(n);
        const int INF=0x3f3f3f3f;
        //dp[i][j]表示前i个数里，平方数和恰好为j的最少平方数数量
        vector<vector<int>> dp(m+1,vector<int>(n+1,INF));
        for(int i=0;i<=m;++i)dp[i][0]=0;
        for(int i=1;i<=m;++i)
        {
            for(int j=1;j<=n;++j)
            {
                dp[i][j]=dp[i-1][j];
                //完全背包二次考虑[i]不是[i-1]
                if(j>=i*i)dp[i][j]=min(dp[i][j],dp[i][j-i*i]+1);
            }
        }
        return dp[m][n];
    }
};

空间优化：

class Solution {
public:
    int numSquares(int n) {
        int m=sqrt(n);
        const int INF=0x3f3f3f3f;
        //dp[i][j]表示前i个数里，平方数和恰好为j的最少平方数数量
        vector<int> dp(n+1,INF);
        dp[0]=0;
        for(int i=1;i<=m;++i)
        {
            for(int j=i*i;j<=n;++j)
            {
                //完全背包二次考虑[i]不是[i-1]
                dp[j]=min(dp[j],dp[j-i*i]+1);
            }
        }
        return dp[n];
    }
};

No.5 数位成本和为目标值的最大数字

1449. 数位成本和为目标值的最大数字 - 力扣（LeetCode）

class Solution {
public:
    string largestNumber(vector<int>& cost, int target) {
        //dp[i][j]表示前i个数中恰好凑成j的最大长度
        int n=cost.size();
        const int INF=0x3f3f3f3f;
        //存在凑不成的情况，用-1表示
        vector<int> dp(target+1,-INF);
        dp[0]=1;
        for(int i=1;i<=n;++i)
        {
            for(int j=cost[i-1];j<=target;++j)
            {
                //注意映射
                dp[j]=max(dp[j],dp[j-cost[i-1]]+1);
            }
        }
        //特殊判断
        if(dp[target]<0)return "0";

        //输出最大的情况,为了保证最大，贪心倒着遍历，查看有没有这个状态即可
        string ret;
        for(int i=9;i>=1;--i)
        {
            int tmp=cost[i-1];
            //表示可以添加这个数，并且这个情况是存在的
            while(target>=tmp&&dp[target]==dp[target-tmp]+1)
            {
                ret+=to_string(i);
                target-=tmp;
            }
        }
        return ret;
    }
};

No.6 获得分数的方法数

2585. 获得分数的方法数 - 力扣（LeetCode）

多重背包就是选择有限次数，但不是1，其实就是介于01背包和完全背包之间的一种情况。

class Solution {
public:
    int waysToReachTarget(int target, vector<vector<int>>& types) {
        const int MOD = 1e9 + 7;
        int n = types.size();
        // dp[i][j]表示前i个种类题里边选，恰好凑成j的方法数
        vector<vector<int>> dp(n + 1, vector<int>(target + 1));
        dp[0][0] = 1;
        for (int i = 1; i <= n; ++i) {
            //注意映射
            int count = types[i - 1][0], mark = types[i - 1][1];
            //从0开始，或者初始化时将第一列全部初始化为1
            for (int j = 0; j <= target; ++j) {
                dp[i][j] += dp[i - 1][j];
                for (int k = 1; k <= count; ++k) {
                    if (j >= k * mark)
                        //注意不是i,是i-1
                        dp[i][j] = (dp[i][j]+dp[i-1][j - k * mark])%MOD;
                }
            }
        }
        return dp[n][target];
    }
};

空间优化：
 

class Solution {
public:
    int waysToReachTarget(int target, vector<vector<int>>& types) {
        const int MOD = 1e9 + 7;
        int n = types.size();
        // dp[i][j]表示前i个种类题里边选，恰好凑成j的方法数
        vector<int> dp(target + 1);
        dp[0] = 1;
        for (int i = 1; i <= n; ++i) {
            //注意映射
            int count = types[i - 1][0], mark = types[i - 1][1];
            //从0开始，或者初始化时将第一列全部初始化为1
            //和01背包那样，因为要访问左上方的那个数据所以横向要倒着遍历
            for (int j = target; j >=0; --j) {
                count=min(count,j/mark);
                for (int k = 1; k <= count; ++k) {
                    if (j >= k * mark)
                        //注意不是i,是i-1
                        dp[j] = (dp[j]+dp[j - k * mark])%MOD;
                }
            }
        }
        return dp[target];
    }
};

No.7 和带限制的子多重集合的数目

2902. 和带限制的子多重集合的数目 - 力扣（LeetCode）

首先我们肯定不能像之前一样从开始到末尾遍历数组更新dp了，因为这里要求不能重复，按原先的方法必然导致重复。为了避免，可以用哈希表存数据，遍历哈希表，对每一个元素单独进行讨论即可，如此就可以避免出现相同结果。

此外可以发现这是一个多重背包，对于在区间内l,r最后返回dp[l~r]即可，很好解读。

直接写空间优化代码：

j倒着遍历也是因为需要访问 i-1 j-XXX 位置的数据，只能倒着遍历，按顺序遍历会覆盖我后续需要的值

class Solution {
public:
    int countSubMultisets(vector<int>& nums, int l, int r) {
        //dp[i]表示恰好达到i的子集合总数
        const int MOD=1e9+7;
        int n=nums.size();
        unordered_map<int,int> hash;

        int TotalSum=0;
        for(auto&x:nums)
        {
            TotalSum+=x;
            ++hash[x];
        }
        r=min(TotalSum,r);//更新一下能抵达的最右边界

        vector<int> dp(r+1);
        dp[0]=hash[0]+1;
        hash.erase(0);

        for(auto&[x,count]:hash)
        {
            for(int j=r;j>=x;--j)
            {
                count=min(count,j/x);
                for(int k=1;k<=count;++k)
                {
                    dp[j]=(dp[j]+dp[j-k*x])%MOD;
                }
            }
        }

        int ret=0;
        for(int j=l;j<=r;++j)ret+=dp[j];
        return ret;
    }
};

运行通过，代码没有问题，但是一运行就会超时报错，意味着还有优化空间

class Solution {
public:
    int countSubMultisets(vector<int>& nums, int l, int r) {
        //dp[i]表示恰好达到i的子集合总数
        const int MOD=1e9+7;
        int n=nums.size();
        unordered_map<int,int> hash;

        int TotalSum=0;
        for(auto&x:nums)
        {
            TotalSum+=x;
            ++hash[x];
        }
        r=min(TotalSum,r);//更新一下能抵达的最右边界

        vector<int> dp(r+1);
        dp[0]=hash[0]+1;
        hash.erase(0);

        int sum;
        for(auto&[x,count]:hash)
        {
            //当前能达到的最大和
            sum=min(sum+x*count,r);
            //先统一计算，而后删除重复项
            for(int j=x;j<=sum;++j)dp[j]=(dp[j]+dp[j-x])%MOD;
            for(int j=sum;j>=x*(count+1);--j)
            //保证结果为符合题意的正数
            dp[j]=(dp[j]-dp[j-x*(count+1)]+MOD)%MOD;
        }

        int ret=0;
        for(int j=l;j<=r;++j)ret=(ret+dp[j])%MOD;
        return ret;
    }
};

此篇完。

DP：完全背包+多重背包问题
weixin_51142926的博客
06-21 1259
完全背包：可以多次选择一个物品 多重背包：可以多次选择但是有次数限制
[C++] 完全&多重背包问题
szdytom的博客
03-20 3936
文章目录一·完全背包问题1. 题目2. 思路二·多重背包问题1.题目2.思路 一·完全背包问题 1. 题目 有NNN种物品和一个容量为 VVV 的背包，每种物品都有无限件可用。放入第 iii 种物品的耗费的空间是CiC_iCi​，得到的价值是WiW_iWi​。求解：将哪些物品装入背包，可使这些物品的耗费的空间总和不超过背包容量，且价值总和最大。 2. 思路 题目虽然说得有无限多个，但事实上最多装[...
背包模型模板（0/1、分组、完全、多重）
m0_70897036的博客
06-02 1272
题目描述给一个能承重V的背包，和n件物品，我们用重量和价值的二元组来表示一个物品，第i件物品表示为（Vi，Wi），问：在背包不超重的情况下，得到物品的最大价值是多少？输入第一行输入两个数 V,n，分别代表背包的最大承重和物品数。接下来n行，每行两个数Vi,Wi，分别代表第i件物品的重量和价值。输出输出一个整数，代表在背包不超重情况下所装物品的最大价值。样例输入115 44 103 712 129 8样例输出119。
经典背包问题 01背包+完全背包+多重背包
LYHVOYAGE的专栏
04-06 3万+
01 背包 有n 种不同的物品，每个物品有两个属性，size 体积，value 价值，现在给一个容量为 w 的背包，问最多可带走多少价值的物品。           int f[w+1];   //f[x] 表示背包容量为x 时的最大价值           for (int i=0; i             for (int j=w; j>=size[i]; j--)
史上最易懂的01背包，完全背包，多重背包讲解
K键盘里的青春K
08-17 1万+
背包之01背包、完全背包、多重背包详解   PS：大家觉得写得还过得去，就帮我把博客顶一下，谢谢。 首先说下动态规划，动态规划这东西就和递归一样，只能找局部关系，若想全部列出来，是很难的，比如汉诺塔。你可以说先把除最后一层的其他所有层都移动到2，再把最后一层移动到3，最后再把其余的从2移动到3，这是一个直观的关系，但是想列举出来是很难的，也许当层数n=3时还可以模拟下，再大一些就不可能了，所
01背包，完全背包，多重背包的个人总结
Linnnnnger的博客
04-20 1万+
大一刚接触背包问题的时候就觉得绕。那时候真的是一点代码基础都没有强行去理解。每次都是以失败告终，一直到大二都还不会写背包问题。 后来某次模拟赛之后碰到了背包问题，觉得这个还是挺简单的，终于是下定决心准备搞一搞这个东西了。 有了一定的基础理解起来就比以前容易多了。 首先，先分清楚这三个背包问题。 1.01背包：有n种物品与承重为m的背包。每种物品只有一件，每个物品都有对应的重量weight[
01背包，完全背包，多重背包问题总结
qq_40819252的博客
03-21 2652
背包问题是很经典的一类题目，解决问题的重点是动态规划的状态转换。用了很久才大概弄明白了三种问题的解决方法，今天做一下总结。 01背包 首先是01背包，即给定N个物品，给出它们的价值和所占用的体积，再给定一个背包容量，要求再不超过背包容量的条件下能取得的最大值。一个经典的01背包问题就是Bone Collector。 动态规划的基本思想就是把大问题转化为小问题，通过前面解决过的小问题最终解决大问题；...
深入学习C++：背包动规的基础模型
善良的小乔的博客
06-17 922
本文介绍了动态规划中的经典背包问题及其解法。主要包含五种类型：1）0-1背包（物品只能选一次），使用二维状态转移和一维空间优化；2）完全背包（物品无限选），需正序遍历；3）多重背包（物品有限数量），采用二进制拆分优化；4）分组背包（每组选一个物品）；5）变种问题如二维费用背包。每种类型都给出了状态定义、转移方程及实现代码，并指出解题关键点在于正确理解问题类型、定义状态和优化空间。
01背包输出路径、完全背包、多重背包
qq_51070956的博客
02-26 2783
背包问题01 Knapsack（输出路径- >选的物品)完全背包恰好占用了m这么多的背包容量？？？多重背包问题Ⅰ多重背包问题Ⅱ 01 Knapsack（输出路径- >选的物品) #include <iostream> #include <stack> #include <string.h> using namespace std; const int N=105; int w[N]; int v[N]; int path[N][1005];//path[i][
动态规划——详解经典的完全背包与多重背包问题
TechFlow的博客
03-26 1773
今天是算法数据结构专题的第13篇文章，也是动态规划专题的第二篇。 上一讲当中我们一起学习了动态规划算法中的零一背包问题，我们知道了所谓的零一背包是指每一种物品只有一个，所以它的状态只有0和1两种，即拿或者不拿。而今天我们要来讨论物品不止有一个的情况，物品不止有一个也分两种，一种是不作任何限制，要多少有多少，这种称为完全背包问题，另一种是依然有个数限制，这种称为多重背包问题。 我们一个一个来看，我...
背包问题（完全背包，多重背包，分组背包）
muziliru的博客
07-03 1660
文章目录完全背包多重背包分组背包 完全背包 完全背包就是有n个物品，第i（1<= i <= n）个物品的价值为v[i]，重量为w[i]，可以不限次数的选，问背包容量为m能装的最大价值。 先看看01背包怎么写： for(int i = n;i >= 1;i--){ for(int j = m;j >= w[i];j--){ dp[j] = max(dp[j],dp[j-w[i]] + w[i]); } } 这里只讲空间优化的情况：第二层for循环是倒叙的，因为第i个物品的状态
背包小结（01背包 + 完全背包 + 多重背包 板子）
菜鸡成长史
07-10 2622
首先来比较下三个问题！！ 【01背包】 给你n种不同的物品，每个物品有自己的重量w[i]，和价值v[i]，如果每个物品只能拿一次，给你容量为m的背包，怎样才能取得最大价值？ 【完全背包】 给你n种不同的物品，每个物品有自己的重量w[i]，和价值v[i]，一个物品可以拿多次，给你容量为m的背包，怎样才能取得最大价值？ 【多重背包】 给你n种不同的物品，每个物品有自己的重量w[i]，和价值...
背包详解：完全背包与多重背包
梅桂子的博客
08-30 3902
目录 完全背包 优化一：输入优化 优化二：二进制 优化三：重复放入的 01 背包 多重背包 总结 完全背包 有一个大小为 m 的背包，有 N 种物体，每种物品的价值为 Vi, 大小为 Ai, 并且每种物品有无限个，请问背包能容纳的最大价值是多大？ (Lintcode - 440)   这就是完全背包问题，完全背包是指物品的数量都是无限个。   显然，我们可以将其转...
动态规划：完全背包、多重背包
热门推荐
Allen的博客
07-20 6万+
一、问题描述： 　　完全背包：有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。　　　　 　　多重背包：有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值...
c++01背包、完全背包、多重背包思路+代码
lukehong_的博客
09-06 1704
今天蒟蒻来给大家讲01背包、完全背包、多重背包的思路和代码 一.先来区分一下这三种背包的区别 01背包：有N件物品和一个容量为V的背包。（每种物品均只有一件）第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。 完全背包：有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 多重背包：有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费
背包动规问题简单汇总（初学者版）
csbzyy的博客
12-25 780
作为一个初学背包动规的蒟蒻，简单分享下几种常见的题型。（dalao嘴下留情）文章部分内容来自《算法竞赛进阶指南》--李煜东。
01背包、完全背包、多重背包详解
qq_22228095的博客
10-08 2699
目录 一、01背包问题 二、完全背包问题 三、多重背包 一、01背包问题 问题： 有n件物品和一个容量是m的背包。第i件物品的体积是vi，价值是wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。 解答： 问题中每个物品只有选与不选两种状态。 动态规划的状态转移方程：dp[i][j] = max(dp[i-1][j], dp[i][j-vi]+wi) , d[i][j]表示只看前i个物品且总体积是j时，最大的价值。 //v是物品的体积，w是价
背包问题扩展-多重背包、完全背包、混合背包
Gaoithe的博客
05-02 1672
本篇文章以https://blog.csdn.net/sinat_40471574/article/details/89740300为基础，在阅读本篇文章之前，最好先看一下。 上一篇文章介绍了01背包问题，接下来我将介绍01背包的扩展问题：多重背包、完全背包以及混合背包。 1. 多重背包：http://acm.nefu.edu.cn/JudgeOnline/problemShow.php?pr...
背包之01背包、完全背包、多重背包详解
Augusdi的专栏
09-17 1478
首先说下动态规划，动态规划这东西就和递归一样，只能找局部关系，若想全部列出来，是很难的，比如汉诺塔。你可以说先把除最后一层的其他所有层都移动到2，再把最后一层移动到3，最后再把其余的从2移动到3，这是一个直观的关系，但是想列举出来是很难的，也许当层数n=3时还可以模拟下，再大一些就不可能了，所以，诸如递归，动态规划之类的，不能细想，只能找局部关系。 图1.汉诺塔图片 （引至杭电课件:DP最关键的就是状态，在DP时用到的数组时，也就是存储的每个状态的最优值，也就是记忆化搜索） 要了解背包，首先得清楚
OpenCV 核心算法大全、解决问题 + 落地应用完整详解
最新发布
雪的季节
06-29 170
整体分为 7 大模块：基础图像操作、滤波平滑、边缘 / 特征检测、轮廓与形状分析、特征匹配与目标识别、相机标定三维视觉、视频与机器学习，每个模块包含核心算法、解决痛点、实际工程场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_dindong

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

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

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

打赏作者

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

抵扣说明：

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

余额充值