给你一个整数数组 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

---

回溯算法时间复杂度为 O(S^n)会超时，需要更加高效的算法

class Solution {
    int ans = INT_MAX;
    void backtrack(vector<int>& coins, int index, int count, int target) {
        // cout << index << " " << count << " " << target << endl;
        if (count > ans) {
            return;
        }
        if (target <= 0) {
            if (target == 0) {
                ans = min(ans, count);
            }
            return;
        }
        
        for (int i = index; i < coins.size(); i++) {
            count++;
            backtrack(coins, i, count, target-coins[i]);
            count--;
            backtrack(coins, i+1, count, target);
        }
    }
public:
    int coinChange(vector<int>& coins, int amount) {
        sort(coins.begin(), coins.end(), greater<int>());
        backtrack(coins, 0, 0, amount);
        return ans == INT_MAX ? -1 : ans;
    }
};

动态规划

记录F(S)：组成金额 S 所需的最少硬币数量 最后一枚硬币面值为C，则F(S)=F(S−C)+1, C需要遍历并选择最小的F(S-C)

我们一共需要计算 S 个状态的答案，且每个状态 F(S) 由于上面的记忆化的措施只计算了一次，而计算一个状态的答案需要枚举 n 个面额值，所以一共需要 O(Sn) 的时间复杂度。

自底向上计算叫动态规划，自顶向下叫记忆化搜索？

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        //从0到amount共amount+1个数, 最大硬币个数不会超过amount/1=amount(硬币大小为1),
        vector<int> dp(amount+1, amount+1);
        dp[0] = 0;
        for (int i = 1; i <= amount; i++) {
            for (auto coin : coins) {
                if (i-coin >= 0) {
                    dp[i] = min(dp[i], dp[i-coin]+1);
                }
            }
        }
        return dp[amount] > amount ? -1 : dp[amount];
    }
};