322.Coin Change(动态规划之最少硬币问题，滚动数组不明白)

problems:
You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

Example 1:

Input: coins = [1, 2, 5], amount = 11
Output: 3
Explanation: 11 = 5 + 5 + 1

Example 2:

Input: coins = [2], amount = 3
Output: -1
tip:
已知有几种金额的硬币，每种硬币都有无穷多个，让你用最少的硬币凑出要求的金额，如果凑不出则返回-1，否则返回最少的硬币数量。动态规划把问题分为子为题，解决了这些子问题，再把子问题合并起来，便可以得到问题的解。在解决子问题过程中，需要把子问题的解保存起来方便后面使用。最少硬币找零问题为：给予不同面值的硬币若干种（每种硬币个数无限多），用若干种硬币组合为某种面额的钱，使硬币的的个数最少。在现实生活中，我们往往使用的是贪心算法，比如找零时需要13元，我们先找10元，再找2元，再找1元。这是因为现实生活中的硬币（纸币）种类特殊。如果我们的零钱可用的有1、2、5、9、10。我们找零18元时，贪心算法的策略是：10+5+2+1，四种，但是明明可以用两个9元的啊。
所以可以使用动态规划，找零18元时，我们首先找18-1=17，18-2=15，18-5,=13，18-9,=9，18-10=8；再找17-1……。这样递归解决子问题。
参考以下内容，对整个过程解释的很通俗易懂：
① https://www.codercto.com/a/21454.html
② https://ask.julyedu.com/article/402
solutions:
1.递归求解，会超时（递归其实也是暴力求解）：①边界条件 ②递归公式

class Solution {
public:
    int maxValue = 10000;//设置为最大值还是最小值要与判断方向相反
    int search(int idx,vector<int>& coins,int amount)
    {
        if(idx >= coins.size()) return maxValue;//这些边界值因为会参与递归计算所以不能随便给值
        if(amount < 0) return maxValue;
        if(amount == 0) return 0;
        return min(search(idx,coins,amount-coins[idx])+1,search(idx+1,coins,amount));
    }
    int coinChange(vector<int>& coins, int amount) {
        int a=search(0,coins,amount);
        if(a == maxValue) return -1;
        else
            return a;
    }
};

2.递归+数组(超时)：计划搜索。把计算过的状态的值用数组存储（保存中间结果）。

class Solution {
public:
    int maxValue = 10000;
    int search(int idx,vector<int>& coins,int amount,vector<vector<int>> vec)
    {
        if(idx >= coins.size()) return maxValue;
        if(amount < 0) return maxValue;
        if(amount == 0) return 0;
        if(vec[idx][amount] != maxValue) return vec[idx][amount];
        //可以反复取同一个硬币，所以idx不加1，只有我不想取的时候才+1
        int a = search(idx,coins,amount-coins[idx],vec)+1;
        int b = search(idx+1,coins,amount,vec);
        vec[idx][amount]=min(a,b); 
        return min(a+1,b);
    }
    int coinChange(vector<int>& coins, int amount) {
        vector<int> tip(amount+1,maxValue);
        vector<vector<int>> vec(coins.size()+1,tip);//开一个二维数组用于存储已经计算过的状态
        int a=search(0,coins,amount,vec);
        if(a == maxValue) return -1;
        else
            return a;
    }
};

3.二维数组的动态规划：https://ask.julyedu.com/article/402

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

4.改写为滚动数组的方式，然后再优化为一维数组的方式还没有看懂。