lintcode：799 背包问题VIII

最新推荐文章于 2024-10-15 19:28:18 发布

OceanStar的学习笔记

最新推荐文章于 2024-10-15 19:28:18 发布

阅读量141

点赞数

分类专栏：算法与数据结构文章标签：动态规划 leetcode 算法

原文链接：https://www.lintcode.com/problem/799/note/147377

版权

算法与数据结构专栏收录该内容

1135 篇文章 84 订阅

订阅专栏

该博客讨论了如何使用动态规划解决一个涉及有限硬币数量的多维背包问题。题目要求计算1到n的数值中有多少可以用给定的硬币组合出来。博主提供了两种不同的动态规划解决方案，分别详细解释了状态定义、转移方程、初始条件以及时间复杂度。通过这两种方法，可以找出能用硬币组合成的所有可能数值，从而得到答案。

摘要由CSDN通过智能技术生成

题目来源

lintcode

题目描述

在这里插入图片描述

class Solution {
public:
    int backPackVIII(int n, vector<int> &value, vector<int> &amount){
        
    }
};

题目解析

题目要求：1~n这些数值中，有多少是可以用这些组成的组成的。相当于有容量为1~n的背包，能装满的背包数量（不需要关心到底有几种方案能装满当前这个容量，只要求能装满）

硬币数量有限

多维背包

思路一

（1）定义状态：

dp[i][j]：对于前i个硬币，是否能装满容量为j的背包
- i: 0 ~ m
- j: 0 ~ n

（2）转移方程

dp[i][j] = dp[i - 1][j - k * value[i - 1]], k: 0 ~ amount[i - 1]

（3）初始条件

$d p [0] [j] = f a l s e, j > 0$
$d p [i] [0] = t r u e$

（4）答案

$c o u n t d p [m] [j], j : 1 n$

（5）时间复杂度

时间复杂度：O(n x m x k)
空间复杂度：O(n * m)

class Solution {
public:
    int backPackVIII(int n, vector<int> &value, vector<int> &amount){
        int len = value.size();

        //dp[i][j]前i个硬币能否组成价值j
        std::vector<std::vector<bool>> dp(len + 1, std::vector<bool>(n + 1));

        for (int i = 0; i <= len; ++i) {
            dp[i][0] = true;
        }

        for (int i = 1; i <= len; ++i) {  // 硬币
            int amt = amount[i - 1], val = value[i - 1];
            for (int j = 1; j <= n; ++j) {  //容量
                for (int k = 1; k <= amt; ++k) {   //件数
                    dp[i][j] = dp[i - 1][j];
                    if(j - val * k >= 0){
                        dp[i][j] = dp[i - 1][j] || dp[i - 1][j - val * k];
                    }
                }
            }
        }

        int result = 0;
        for (int j = 1; j <= n; j++) {
            if (dp[len][j]) {
                result++; //题目要求1-n的j的个数
            }
        }

        return result;
    }
};

思路

（1）状态

dp[i]表示coins是否可以组合成i的值。

class Solution {
public:
    int backPackVIII(int n, vector<int> &value, vector<int> &amount){
        std::vector<bool> dp(n + 1, false);
        
        int len = value.size();

        dp[0] = true;
        for (int i = 1; i <= len; ++i) {
            int amt = amount[i - 1], val = value[i - 1];
            for (int j = 1; j <= amt; ++j) {
                for (int k = n; k >= val; --k) {
                    if (!dp[k] && dp[k - value[i]]) { //记得!dp[k]可以剪枝
                        dp[k] = true;
                    }
                }
            }
        }



        int sum = 0;
        for (int i = 1; i <= n; ++i) {
            if (dp[i]) sum++;
        }

        return sum;
    }
};