动态规划、背包（零钱兑换）

题目

leetcode链接
给你一个整数数组 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
示例 4：

输入：coins = [1], amount = 1
输出：1
示例 5：

输入：coins = [1], amount = 2
输出：2

看过一次背包问题的讲解，这次遇到了但是想不起来，使用回溯，即使剪枝，也超时了。

看了答案的动态转移方程，然后自己写了下：时间35% 内存21%

/*
coins.size()个物品，背包容量amount
物品可以重复用，完全背包问题


dp[i]=min{dp[i-coins[0]],dp[i-coins[1]],dp[i-coins[2]]......dp[i-coins[j]]}+1
i表示组成金额i时需要的最少硬币数量
*/

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

    }
};

回溯超时的写法（[1,2,5] [100]）

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    int coinChange(vector<int>& coins, int amount) {
        back_tracking(coins,amount);
        if(res.size()==0){
            return -1;
        }
        int min_len=999;
        for(int i=0;i<res.size();i++){
            if(min_len>res[i].size()){
                min_len=res[i].size();
            }
        }
        return min_len;
    }
    void back_tracking(vector<int> coins,int amount){
        if(amount==0){
            res.push_back(path);
        }
        if(amount<0){
            return ;
        }
        for(int i=0;i<coins.size();i++){
            path.push_back(coins[i]);
            back_tracking(coins,amount-coins[i]);
            path.pop_back();
        }
    }
};