【动态规划】【完全背包】力扣322. 零钱兑换

给你一个整数数组 coins ,表示不同面额的硬币;以及一个整数 amount ,表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额,返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1:
输入:coins = [1, 2, 5], amount = 11
输出:3
解释:11 = 5 + 5 + 1

示例 2:
输入:coins = [2], amount = 3
输出:-1

示例 3:
输入:coins = [1], amount = 0
输出:0
【动态规划】【完全背包】力扣322. 零钱兑换_第1张图片
法一:回溯+记忆化搜索

class Solution {
    vector<int> count;
    int dp(vector<int>& coins, int rem) {
        if(rem == 0) return 0;
        if(rem < 0) return -1;
        if(count[rem-1] != 0) return count[rem-1];

        int Min = INT_MAX;
        for(int coin : coins){
            int res = dp(coins, rem - coin);
            if(res >= 0 && res < Min){
                Min = res + 1;
            }
        }
        count[rem-1] = Min == INT_MAX ? -1 : Min;
        return count[rem-1];
    }
public:
    int coinChange(vector<int>& coins, int amount) {
        if(amount == 0){
            return 0;
        }
        count.resize(amount);
        return dp(coins, amount);
    }
};

时间复杂度:O(Sn),其中 S 是金额,n 是面额数。我们一共需要计算 S 个状态的答案,且每个状态 F(S) 由于上面的记忆化的措施只计算了一次,而计算一个状态的答案需要枚举 n 个面额值,所以一共需要 O(Sn) 的时间复杂度。
空间复杂度:O(S),我们需要额外开一个长为 S 的数组来存储计算出来的答案 F(S) 。

回溯部分:

int dp(vector<int>& coins, int rem) {
        if(rem == 0) return 0;
        if(rem < 0) return -1;
        if(count[rem-1] != 0) return count[rem-1];

        int Min = INT_MAX;
        for(int coin : coins){
            int res = dp(coins, rem - coin);
            if(res >= 0 && res < Min){
                Min = res + 1;
            }
        }
        count[rem-1] = Min == INT_MAX ? -1 : Min;
        return count[rem-1];
    }

我们定义一个大小在主函数coinChange中定义为amount的数组count来记忆化,减少重复运算额。首先dp的定义是,coins也就是可选择的coins,rem也就是目标金额,也就是说dp(coins, rem)的含义就是,要凑成rem金额,最少需要多少枚硬币。

假设我们在主函数coinChange传入树的头结点dp(coins, amount),那么会发生什么过程?首先dp要计算最少需要多少枚硬币才能凑到目标金额,这时候他就会枚举如果拿了coin金额的一个硬币,那么只要再凑rem-coin金额即可。那么要计算dp(coins, rem),不就是dp(coins, rem - coin) + 1吗,反过来想就是凑够rem - coin金额需要dp(coins, rem-coin)个硬币,那么再拿一个面值为coin的硬币,就可以凑成rem金额,然后硬币数量+1就是最小金额。但是由于dp(coins,rem-coin)由许多种情况构成,coin可以是不同面额,那么为了凑成价值为rem金额的最小硬币数量,就要求coin要满足dp(coins,rem-coin)必须是所有coin情况的最小的硬币数量,这时候再拿一个价值为coin的硬币,才是dp(coins,rem)的最小硬币组合数。这也就是为什么我们要遍历coins中每一个coin的情况,然后才能找到最小的res是多少,然后让他+1 = Min(注意:Min是局部变量,在每个递归中都存在,互不影响)。

有人会好奇那么不断找到最后,会发生什么,当rem == 0的时候,也就是末节点,实际上的含义也就是凑成金额0需要0种组合,这时候他的父节点就会计算res为0,然后记录Min为res+1 = 1。还有一种情况是rem最后小于0,那么说明这种组合是不合理的,这样子,这样一个路径上的coin金额加起来会大于你的目标amount,所以返回-1来说明这种情况不合理,这时候父节点的res由于小于0,则不会考虑记录到Min中。

最后也就是记忆每一种rem的金额的最小硬币数,下次计算金额为rem的dp,就会直接返回count中储存的结果。

法二:动态规划

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int>dp(amount+1, amount+1);
        dp[0] = 0;
        for(int i = 1; i <= amount; i++){
            for(int j = 0; j < coins.size(); j++){
                if(coins[j] <= i){
                    dp[i] = min(dp[i], dp[i-coins[j]]+1);
                }
            }
        }
        return dp[amount] == amount + 1 ? -1 : dp[amount];
    }
};

时间复杂度:O(Sn),其中 S 是金额,n 是面额数。我们一共需要计算 O(S) 个状态,S 为题目所给的总金额。对于每个状态,每次需要枚举 n 个面额来转移状态,所以一共需要 O(Sn) 的时间复杂度。
空间复杂度:O(S)。数组 dp 需要开长度为总金额 S 的空间。

首先是初始化一个大小为amount+1的数组,并初始化所有元素为amount + 1,表示一个不可能的高值,用来初始化 dp 数组。因为不可能需要超过 amount 个硬币来凑成 amount,所以用 amount + 1 来初始化表示不可能的解。

然后遍历从 1 到 amount 的每个金额 i,试图找到每个金额 i 需要的最少硬币数。
内层循环:for (int j = 0; j < (int)coins.size(); ++j),遍历每个硬币面额 coins[j],如果 coins[j] <= i,就可以尝试使用这个硬币凑出金额 i。
dp[i - coins[j]] + 1:表示在凑成金额 i - coins[j] 的基础上再加上一个面额为 coins[j] 的硬币,来凑出金额 i。
dp[i] = min(dp[i], dp[i - coins[j]] + 1):更新 dp[i],取当前 dp[i] 和 dp[i - coins[j]] + 1 的较小值,表示凑出金额 i 所需的最少硬币数。

最后如果dp[amount]没有被更新,返回-1,否则返回能组成该金额的最小硬币数。

你可能感兴趣的:(精选,动态规划,动态规划,leetcode,算法)