动态规划背包问题c++

最新推荐文章于 2024-03-02 22:43:00 发布
最新推荐文章于 2024-03-02 22:43:00 发布
阅读量420 收藏
点赞数 1
分类专栏： c算法 文章标签： 动态规划 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010918541/article/details/123070408
版权

动态规划背包问题

背包问题

01 背包问题

求出限重在j情况下的 可以放入物品的最大价值V， 每个物品只有1个
初始化条件
vector weights = {1,3,5,4,6,4,2};
vector values = {2,4,6,3,1,5,5};

设定 d[i][j] 表示为 (前i个物品在限重j重量下所呈现的,前i个物品不清楚里面具体放了哪几个) 最大价值
设定 d[i - 1][j] 表示为 (前i个物品在限重j重量下所呈现的,前i -1 个物品不清楚里面具体放了哪几个) 最大价值

假如现在的状态是 d[i - 1][j], 已经明确了前i-1个物品所带来的最大价值,
那么第i个物品不放入背包的价值为
d[i][j] = d[i-1][j]
那么第i个物品选择放入背包的价值为
当前物品的价值 + 前i-1个物品在限重 [j - 当前物品重量下的限重] 的最大价值
d[i][j] = value[i]+ dp[i-1][j - wights[i]]

那么状态转移公式应该为 选择两者放入与不放入的中的最大值
d[i][j] = max ( d[i-1][j] , value[i]+ dp[i-1][j - wights[i]])

初始化dp[0][1,2,…j] = 0
我们手动推理写下这个过程

考虑前1个物体在限重0,1,2,3,…j 的 最大价值

d[1][0] = d[0][0] = 0
d[1][1] = max ( d[0][1], 2 + d[0][1 - 1]) = 2
d[1][2] = max ( d[0][2], 2 + d[0][2 - 1 ]) = 2
d[1][3] = max ( d[0][3], 2 + d[0][3 - 1]) = 2
d[1][4] = max ( d[0][4], 2 + d[0][4 - 1]) = 2
d[1][5] = max ( d[0][5], 2 + d[0][5 - 1]) = 2
d[1][6] = max ( d[0][6], 2 + d[0][6 - 1]) = 2

d[2][0] = d[1][0] = 0
d[2][1] = max ( d[1][1], 4 + d[1][1-3]) = 2
d[2][2] = max ( d[1][2], 4 + d[1][2-3]) = 2
d[2][3] = max ( d[1][3], 4 + d[1][0]) = 4
d[2][4] = max ( d[1][4], 4 + d[1][1]) = 6
d[2][5] = max ( d[1][5], 4 + d[1][2]) = 6
d[2][6] = max ( d[1][6], 4 + d[1][3]) = 6

d[3][0] = d[2][0] = 0
d[3][1] = max ( d[2][1] 2, 6 + d[2][1-5]) = 6
d[3][2] = max ( d[2][2] 2, 6 + d[2][2-5]) = 6
d[3][3] = max ( d[2][3] 2, 6 + d[2][3-5]) = 6
d[3][4] = max ( d[2][4] 6, 6 + d[2][4-5]) = 6
d[3][5] = max ( d[2][5] 6, 6 + d[2][0]) = 6
d[3][6] = max ( d[2][6] 6, 6 + d[2][1]) = 8

int package_01(int total_wieght)
{

    // 01 背包问题 求限重j下装入物品的最大价值 每个物品只有一个, 不是无限个
    vector<int> weights = {1,3,5,4,6,4,2};
    vector<int> values =  {2,4,6,3,1,5,5};

   //这里开辟的空间是 NM 也就是 weights.size * total_wieght 的大小
   vector<vector<int>> dp(weights.size() + 1, vector<int>(total_wieght + 1,0));
   for(int i = 1; i < weights.size() + 1; i++)
   {
       for(int j = 1; j <= total_wieght; j++)
       {
           //由于从i 从 1 开始 所以这里的对应值应该减去1
           int current_value = values[i -1];
           int current_weight = weights[i-1];
           if(current_weight <= j)
           {
                dp[i][j] = max(dp[i-1][j], current_value + dp[i-1][j-current_weight]);
           }
           else
           {
                dp[i][j] = dp[i-1][j];
           }
            printf("dp[%d][%d] = %d\n",i,j,dp[i][j]);
       }
   }
   return dp[weights.size()][total_wieght];
}

继续观察这个代码 发现开辟的空间数组大小也可以优化 因为dp[i] 每次循环只依赖上次dp[i-1]的结果
只开辟dp[total_weight +1] 的空间就可以满足计算运行
更新公式如下

dp[j] =max( d[j] , values[i] + dp[3-weights[i]] )
假如这里代表dp[2][j]那么这里代表dp[1][j] 和 dp[1][j-weights[i]]

大限重的value 计算 依赖了小限重的value
那么需要反过来从限重从大往小计算最大价值
j = J ,j-1,j-2,3,2,1

int package_01_small_space(int total_wieght)
{

    // 01 背包问题 求限重j下装入物品的最大价值 每个物品只有一个, 不是无限个
    vector<int> weights = {1,3,5,4,6,4,2};
    vector<int> values =  {2,4,6,3,1,5,5};

   //这里开辟的空间是 NM 也就是 total_wieght + 1 的大小
   int dp[total_wieght + 1] ={0};
   for(int i = 1; i < weights.size() + 1; i++)
   {
       //倒序计算
       for(int j = total_wieght; j >= 1; j--)
       {
           //由于从i 从 1 开始 所以这里的对应值应该减去1
           int current_value = values[i -1];
           int current_weight = weights[i-1];
           if(current_weight <= j)
           {
                // not choose this object
                dp[j] = max(dp[j], current_value + dp[j-current_weight]);
           }
           printf("dp[%d][%d] = %d\n",i,j,dp[j]);
       }
   }
   return dp[total_wieght];
}

完全背包问题

01 完全背包问题 求限重j下装入物品的最大价值 每个物品有无限个 求 最大价值
dp[j] 限重j下的最大价值
dp[j-1] 限重j-1下的最大价值
状态转移方程为
for i in 1,2,3,4,N
dp[j] = max(value[i] + dp[j - weight[i]],)

int package_all(int total_wieght)
{
    // 01 完全背包问题 求限重j下装入物品的最大价值 每个物品有无限个 求 最大价值
    vector<int> weights = {1,3,5,4,6,4,2};
    vector<int> values =  {2,4,6,3,1,5,5};
    
    // 设定 d[i][j] 表示为 前i个物品在j重量下所呈现的最大价值
    /*
        dp[j] 代表限重下的最大价值
        dp[j] = max{value[i]+dp[j - weight[i]],.....}
    
    */
   printf("\n\n");
   int dp[total_wieght + 1] ={0};
   for(int j = 1; j <= total_wieght; j++)
   {
       for(int i = 0; i < weights.size(); i++)
       {
           if(weights[i] <= j)
           {
            dp[j] = max(dp[j] ,values[i] + dp[j - weights[i]]);
           }
       }
     printf("dp[%d] = %d\n",j,dp[j]);
   }

   return dp[total_wieght];
}

多重背包问题

多重背包问题
本质分解为
前i个物品在限重下的最大价值
和本次一次性装入k个物品的最大价值 比较

int package_repeated(int total_wieght)
{
    // 01 多重背包问题 求限重j下装入物品的最大价值 每个物品有N个 求 最大价值
    vector<int> weights = {1,3,5,4,6,4,2};
    vector<int> values =  {2,4,6,3,1,5,5};
    vector<int> counts = {2,1,2,3,1,2,3};
    
    // 设定 d[i][j] 表示为 前i个物品在j重量下所呈现的最大价值
    /*
        k 表示装入 k个 i物品
                  总数量      可以装入的最大数量 两者取最小值
        k < min ( counts[i], j / weights[i] )
    
        dp[i][j]
        转移公式
        装入k个物品 不装入k个物品， 没有第几个

        dp[i][j]
            = max(dp[i-1][j], value[i] * k + dp[i-1][j - k * weight[i]])
    */

   int dp[total_wieght + 1] ={0};
   for(int j = 1; j <= total_wieght; j++)
   {
       for(int i = 0; i < weights.size(); i++)
       {
           for(int k = 0 ; k <= counts[i]; k ++)
           {
               if( k * weights[i] <= j)
               {
                   dp[j] = max(dp[j] ,k * values[i] + dp[j - k * weights[i]]);
               }
           }
       }
     printf("dp[%d] = %d\n",j,dp[j]);
   }

   return dp[total_wieght];
}

恰好装满问题

恰好装满背包
与01 背包区别是初始化过程中 dp[0] = 0 dp[others] = -inf

int package_case(int total_wieght)
{
    // 01 恰好装满背包
    vector<int> weights = {3,5,4,6};
    vector<int> values =  {4,6,6,1};
    vector<int> counts = {1,2,3,1,2,3};
    
    // 设定 d[i][j] 表示为 前i个物品在j重量下所呈现的最大价值
    /*
    dp[0] = [0]
    dp[1] = -inf
    dp[2] = 5
    
    //完全背包
    dp[3] = max(4, 5 + dp[1]) = max(4,5+0) = 5
    //恰好背包
    dp[3] = max(4, 5 + dp[1]) = max(4,5+ -inf) = 4
    */

   vector<int> dp(total_wieght+1,std::numeric_limits<int>::min());
   // 所以对int数组进行非0赋值或初始化时不能用memset()函数，只能循环处理/定义时初始化
   dp[0] = 0;

   for(int j = 1; j <= total_wieght; j++)
   {
       for(int i = 0; i < weights.size(); i++)
       {
           if(weights[i] <= j)
           {
            dp[j] = max(dp[j] ,values[i] + dp[j - weights[i]]);
           }
       }
     printf("dp[%d] = %d\n",j,dp[j]);
   }

   return dp[total_wieght];
}

求方案总数

// 方案总数 求所有方案 台阶问题
https://blog.csdn.net/zhuanzhe117/article/details/72846939

int package_sum(int total_wieght)
{
    // 01 上台阶 上100个台阶的总方案数目
    vector<int> weights = {3,5,4,6,2};
   vector<int> dp(total_wieght+1,0);
   dp[0] = 1;
   /*
   https://blog.csdn.net/zhuanzhe117/article/details/72846939

   dp[j] = sum(dp[j-3],dp[j-5],dp[j-4],dp[j-6],dp[j-2])
   */
   // 所以对int数组进行非0赋值或初始化时不能用memset()函数，只能循环处理/定义时初始化

   for(int j = 1; j <= total_wieght; j++)
   {
       for(int i = 0; i < weights.size(); i++)
       {
           if(weights[i] <= j)
           {
            dp[j] = dp[j] + dp[j - weights[i]];
           }
       }
     printf("dp[%d] = %d\n",j,dp[j]);
   }
   return dp[total_wieght];
}

#include <iostream>
#include <string>
#include <vector>
#include <limits>
using namespace std;
int main(int argc, char *argv[])
{
    //solutions(10);
    // std::vector<int> coins = {1,3,5};
    // std::cout << Solution::change(4,coins);
    printf("argv %s\n",argv[1]);
    int a = atoi(argv[1]);
    int res = package_01_small_space(a);
    printf("\npackage_01_small_space %d\n",res);
    res = package_01(a);
    printf("\npackage_01 %d\n",res);

}

参考链接
https://zhuanlan.zhihu.com/p/93857890
https://blog.csdn.net/zhuanzhe117/article/details/72846939

csdn_Flying
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++01背包问题动态规划
01-21
#include using namespace std; const int N=1010; int f[N]; int main() { int n,m; cin>>n>>m; for(int i=0;i;i++) { int v,w; cin>>v>>w; for(int j=m;j>=v;j--) f[j]=max(f[j],f[j-v]+w);...}
动态规划详解
热门推荐
每天学习一点点，成长一小步
03-23 2万+
以下为最常见的使用动态规划的例子： 一、动态规划的三大步骤 动态规划，无非就是利用历史记录，来避免我们的重复计算。而这些历史记录，我们得需要一些变量来保存，一般是用一维数组或者二维数组来保存。下面我们先来讲下做动态规划题很重要的三个步骤： 第一步骤：定义数组元素的含义，上面说了，我们会用一个数组，来保存历史数组，假设用一维数组 dp[] 吧。这个时候有一个非常非常重要的点，就是规定你这个数组元素的含义，例如你的 dp[i] 是代表什么意思？ 第二步骤：找出数组元素之间的关系式，我觉得动态规划，还是有一点类
LeetCode题解——动态规划（四）
wardseptember的博客
03-04 553
文章目录474. 一和零动态规划322. 零钱兑换动态规划518. 零钱兑换 II动态规划139. 单词拆分动态规划377. 组合总和 Ⅳ动态规划推荐阅读 474. 一和零 在计算机界中，我们总是追求用有限的资源获取最大的收益。 现在，假设你分别支配着 m 个 0 和 n 个 1。另外，还有一个仅包含 0 和 1 字符串的数组。 你的任务是使用给定的 m 个 0 和 n 个 1 ，找到能拼出存在于...
C++动态规划01背包问题
最新发布
m0_74158049的博客
03-02 1016
详细讲解了01背包问题的动态规划解法思路。
动态规划法(二)——弗洛伊德算法
大闲人柴毛毛
04-08 6055
问题描述 给定一个带权有向图，计算任意两结点间的最短路径。 迪杰斯特拉算法可以计算指定起点到所有结点的最短路径长度，因此分别对每个结点使用一次迪杰斯特拉算法即可求的任意两结点间的最短路径。迪杰斯特拉算法的时间复杂度为O(n^2)，因此采用这种方法的时间复杂度为O(n^3)。 但是，迪杰斯特拉算法不允许权值为负数，因此需要使用弗洛伊德算法。 弗洛伊德算法允许权值为负数的边，但不允许回路的路径长
动态规划知识总结
weixin_45785536的博客
06-19 355
DP-方法 DP-方法动态规划和分治的联系和区别适合用动态规划解决的问题疑问例子1.多段图2.最优二分检索树 动态规划和分治的联系和区别 1.动态规划和分治相似，都是通过组合子问题的解来求解原问题。 2.分治法：将问题划分为互不相交的子问题，递归求解子问题，再将子问题的解组合起来，求解原问题的解。 动态规划：应用于子问题重叠的情况，即不同的子问题拥有公共的子子问题。（如果用分治法来求解，会反复求解公共的子子问题；用动态规划就求一次。）该方法通常用来解决多阶段决策过程（前后关联，链状结构，多阶段过程）的最优化
【swjtu】算法实验5.4动态规划在实际中的应用
qq_52046937的博客
08-24 522
有一个二维矩阵，矩阵中元素有正也有负。定义子矩阵的和为其所有元素之和，最大子矩阵为子矩阵和值最大的子矩阵。 输入：输入的第一行为N，表示矩阵的行数和列数。其后的N行每行包含N个元素，表示矩阵每行元素的值，元素之间用空格隔开。 输出：输出一行，包含一个整数，表示其最大子矩阵的和。 样例输入：4 0 -2 -7 0 9 2 -6 2 -4 1 -4 1 -1 8 0 -2 要求： 将矩阵的某一行看成一个序列，设
C++动态规划之背包问题解决方法
09-03
主要介绍了C++动态规划之背包问题解决方法,实例分析了背包问题的原理与C++实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
c++用动态规划实现01背包问题
10-20
C++从文件读取数据，利用动态规划实现01背包问题
动态规划 01背包问题 c++代码
10-13
动态规划之01背包问题，cpp示例代码，经测试，编译通过，可直接使用。 背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，...
动态规划求0-1背包问题c++代码
09-10
提供0-1背包问题c++代码，实现功能如下： /**输入参数： * @param m 表示背包的最大容量 * @param n 表示商品个数 * @param a[] 每个商品的容量 * @param p[] 每个商品的价值 */ /**输出： 求最大商品value*/
动态规划问题总结（部分）
weixin_51525912的博客
04-03 211
动态规划相关问题一、最长公共子序列二、子集和问题三、线性动态规划利润 一、最长公共子序列 1、最长公共子序列的定义： 一个序列T，如果分别是两个或两个以上的序列的子序列，且是符合条件最长的，则称T为已知序列的最长公共子序列。*（注：子序列为字符串中不一定连续但先后顺序一致的n个字符）* 2、解决最长公共序列问题采用的是填表的方法 用dp[i][j] 表示X m和Yn 的最长公共子序列的长度，dp[m][n] 就是答案。分三种情况 （1）0 （i= 0，j = 0，X，Y序列有一个空序列）
带负值的背包问题poj2184
nucshiyilang的博客
08-18 2080
1：选的牛要保证两个属性和都要大于0。 2.总和最大！ 想到什么。01背包，一个数要么不用，要么用，让价值最大。 因为会出现负值，并且两个值均大于0 ，那么假设第一种属性已经大于0了--重新设置0点，让100*1000为0点，过了这个点，就说明选的第一个属性和大于0了，反之则没有。那么这时候就只需要管第二种的属性了。把第一种当做消耗来算，第二种属性来算价值（相当于只有花费a，才能得到b。因为
POJ 2148 Cow Exhibition——01背包方法遇到负状态的处理方法
随意凯的博客
05-09 187
首先简单说一下dfs的方法，然后重点介绍dp处理这道题的方法
c++算法----动态规划（背包专题）
qq_63763951的博客
05-02 3398
1.普通背包问题 2.完全背包问题 3.多重背包问题 1.普通背包问题 每到第i个位置就考虑是否拿第i个位置上的物品（当然也要考虑当前背包的体积是否能装得下这个物品），以此类推，直至到达最后一个物品的位置。 #include <iostream> #include <algorithm> using namespace std; /* * 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 *第 i 件物品的体积是 vi，价值是 wi。 *...
C++ DP算法，动态规划——背包问题（背包九讲）
小天狼星_布莱克 的博客
01-28 2282
有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物
01背包的变形问题----背包恰好装满
Iseno_V的博客
09-10 1万+
01背包的变形问题----背包恰好装满 在看本文之前建议先看一下我之前发过的01背包详解。 https://blog.csdn.net/Iseno_V/article/details/100001133 1. 问题的变形 在前面讲到的01背包问题中，现在我们把条件改为 “求当背包恰好装满时候取得的最大价值”。这样的问题其实本质上和原始的01背包问题区别不大，我们只需要做出一点小小的调整。 需要指出...
算法-动态规划-背包问题-C++
weixin_43541510的博客
03-22 677
在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
C++ 算法篇 动态规划----背包之一 01背包
流年的博客
12-21 4543
一、01背包 题目：有 N 件物品和一个容量为 V 的背包。第 i 件物品的费用是 w[i]，价值是 p[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 例，有3个物品，背包容量为10，如下： 二维解法： #include<bits/stdc++.h> using namespace std; int f[50][220]={...
动态规划背包问题 c++代码
05-26
下面是一个简单的 01 背包问题的动态规划实现，用 C++ 编写： ```c++ #include #include using namespace std; int knapsack(int W, vector<int> wt, vector<int> val, int n) { vector<vector<int>> dp(n+1, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值