思路若隐若现，写起来很痛苦，最后去看题解，发现问题出在自己是从0到amount，而题目是从amount到0，而且加上了不同路径求min个数的步骤，用记忆数组来存储已经得到的结果。仔细想想，好像从0到amount也可以，比如从0到amount可以退化成0到amount-coin，然后接着退化，直到当前值小于等于0，其实是一样的。自己的做法其实是缺少了最小值这一步，很关键，贴代码

class Solution {
public:
    vector<int> res;
    int generate(vector<int>& coins,int amount)
    {
        if(amount<0)
        return-1;
        if(amount == 0)
        return 0;
        if(res[amount] != 0)
        return res[amount];
        int min = INT_MAX;
        for(auto coin:coins)
        {
            int res_temp = generate(coins,amount-coin);
            if(res_temp<min && res_temp>=0)
            {
                min = res_temp + 1;
            }
        }
        res[amount] = min == INT_MAX?-1:min;
        return res[amount];      
    }
    int coinChange(vector<int>& coins, int amount) 
    {
        if(amount<1)
        return 0;
        res.resize(amount+1);
        return generate(coins,amount);
    }
};

标准动态规划的方法，还是使用自顶向下的方法，状态转移方程也不难搞，因为之前没处理过min这个条件，所以遇到了一些困难，贴代码

 1 class Solution {
 2 public:
 3     int coinChange(vector<int>& coins, int amount) 
 4     {
 5         int max = amount+1;
 6         vector<int> res(amount+1,max);
 7         res[0] = 0;
 8         for(int i = 1 ; i <= amount ; i++)
 9         {
10             for(auto temp:coins)
11             {
12                 if(i>=temp)
13                 {
14                     res[i] = min(res[i],res[i-temp]+1);
15                 }
16             }
17         }
18         return res[amount] > amount?-1:res[amount];
19     }
20 };