力扣322零钱兑换引发的动态规划算法

动态规划遵循一套固定的流程：递归的暴力解法 -> 带备忘录的递归解法 -> 非递归的动态规划解法。

1. 暴力递归

int fib(int N) {
    if (N == 1 || N == 2) return 1;
    return fib(N - 1) + fib(N - 2);
}

PS：但凡遇到需要递归的问题，最好都画出递归树，这对你分析算法的复杂度，寻找算法低效的原因都有巨大帮助。

这个递归树怎么理解？就是说想要计算原问题 f(20)，我就得先计算出子问题 f(19) 和 f(18)，然后要计算 f(19)，我就要先算出子问题 f(18) 和 f(17)，以此类推。最后遇到 f(1) 或者 f(2) 的时候，结果已知，就能直接返回结果，递归树不再向下生长了。

1.1 递归算法的时间复杂度怎么计算？子问题个数乘以解决一个子问题需要的时间。

子问题个数，即递归树中节点的总数。显然二叉树节点总数为指数级别，所以子问题个数为 O(2^n)。

解决一个子问题的时间，在本算法中，没有循环，只有 f(n - 1) + f(n - 2) 一个加法操作，时间为 O(1)。

所以，这个算法的时间复杂度为 O(2^n)，指数级别，爆炸。

1.2 观察递归树，很明显发现了算法低效的原因：

存在大量重复计算，比如 f(18) 被计算了两次，而且你可以看到，以 f(18) 为根的这个递归树体量巨大，多算一遍，会耗费巨大的时间。更何况，还不止 f(18) 这一个节点被重复计算，所以这个算法及其低效。

2. 带备忘录的递归解法

明确了问题，其实就已经把问题解决了一半。即然耗时的原因是重复计算，那么我们可以造一个「备忘录」，每次算出某个子问题的答案后别急着返回，先记到「备忘录」里再返回；每次遇到一个子问题先去「备忘录」里查一查，如果发现之前已经解决过这个问题了，直接把答案拿出来用，不要再耗时去计算了。

一般使用一个数组充当这个「备忘录」，当然你也可以使用哈希表（字典），思想都是一样的。

实际上，带「备忘录」的递归算法，把一棵存在巨量冗余的递归树通过「剪枝」，改造成了一幅不存在冗余的递归图，极大减少了子问题（即递归图中节点）的个数。

2.1 递归算法的时间复杂度怎么算？子问题个数乘以解决一个子问题需要的时间。

子问题个数，即图中节点的总数，由于本算法不存在冗余计算，子问题就是 f(1), f(2), f(3) … f(20)，数量和输入规模 n = 20 成正比，所以子问题个数为 O(n)。

解决一个子问题的时间，同上，没有什么循环，时间为 O(1)。

所以，本算法的时间复杂度是 O(n)。比起暴力算法，是降维打击。

2.2 带备忘录的递归和动态规划

至此，带备忘录的递归解法的效率已经和动态规划一样了。实际上，这种解法和动态规划的思想已经差不多了，只不过这种方法叫做「自顶向下」，动态规划叫做「自底向上」。

啥叫「自顶向下」？注意我们刚才画的递归树（或者说图），是从上向下延伸，都是从一个规模较大的原问题比如说 f(20)，向下逐渐分解规模，直到 f(1) 和 f(2) 触底，然后逐层返回答案，这就叫「自顶向下」。

啥叫「自底向上」？反过来，我们直接从最底下，最简单，问题规模最小的 f(1) 和 f(2) 开始往上推，直到推到我们想要的答案 f(20)，这就是动态规划的思路，这也是为什么动态规划一般都脱离了递归，而是由循环迭代完成计算。

3. 动态规划

有了上一步「备忘录」的启发，我们可以把这个「备忘录」独立出来成为一张表，就叫做 DP table 吧，在这张表上完成「自底向上」的推算岂不美哉！

int fib(int N) {
    vector<int> dp(N + 1, 0);
    dp[1] = dp[2] = 1;
    for (int i = 3; i <= N; i++)
        dp[i] = dp[i - 1] + dp[i - 2];
    return dp[N];
}

其实根据你想要的结果动态规划可以省去很多空间上的，比如如果你只需要最后的结果，那么完全没有必要用一个数组去保留中间数据，可以直接new一个int类型的数据

4. 回归凑零钱问题

4.1 暴力解法，递归方程

f(0)=0;
//min(f(n-面值))是多个面值的最优解
f(n)=1+ min(f(n-面值))
比如面值分别是[1,5,11]
f(11)=1+min();//f(11-11),f(11-5),f(11-1)里面的最优解 ，最优解是f(11)=f(11)
f(12)=1+min()  ；//f(12-11),f(12-5),f(12-1)里面的最优解,最优解是f(12)=f(11)+f(1)

但是并不是所有的都取面值最大的 最优解就会更好，比如：

f(15)=1+min()  ；//f(15-11),f(15-5),f(15-1)
最优解不是f(15)=f(11)+4f(1)
而是： f(15)=3f(5)

4.2 利用动态规划，求解

for (int money = 1; money <= amount; money++) {
    for (int i = 0; i < coins.length; i++) {
        if (coins[i] <= money) {
            dp[money] = Math.min(dp[money], dp[money - coins[i]] + 1);
        }
    }
    System.out.println(money + "  " + dp[money]);
}

对于上面代码的理解是 ：对于一个定额的钱比如是：99,三种能换的面值1，5，7来说
dp[99]=Math.min(dp[99] , dp[99-1])先求这两个最小值，再求
dp[99]=Math.min(dp[99] , dp[99-5])的最小值 ，最后求
dp[99]=Math.min(dp[99] , dp[99-5])的最小值
因为dp[99]虽然通过上述不能计算出来，但是dp[99]的最小值肯定出现在上面三种情况之中

package com.hcg.dou;

public class LingQian {

    public static int coinChange(int[] coins, int amount) {
        if (amount == 0) {
            return 0;
        }
        int dp[] = new int[amount + 1];
        for (int i = 0; i < dp.length; i++) {
            dp[i] = i;
        }
        for (int money = 1; money <= amount; money++) {
            for (int i = 0; i < coins.length; i++) {
                if (coins[i] <= money) {
                    dp[money] = Math.min(dp[money], dp[money - coins[i]] + 1);
                }
            }
            System.out.println(money + "  " + dp[money]);
        }
        return dp[amount];
    }

    public static void main(String[] args) {
        int coins[] = new int[]{1, 2, 5};
        System.out.println(coinChange(coins, 11));
    }

}

上面的写法是有问题的，虽然可以算出一部分解，但是对于一些不能到达却没有处理，如：硬币只有3，但是你输入一个2，或者5，这时就没有解了
WHY？
因为上面的代码当不能兑换时，dp[amount]=amount导致无法判断是无法兑换还是就是能兑这么多（如;只有1元面值的硬币，但是给了5块钱，这个时候就能兑换5个1元的），所以我们要把dp[i]=account+1一个确定值，当然你也可以设定dp[i]=1000，这时只要在最后的结果判断一下就好了

4.3 修改一下代码，判断是否可达

public static int coinChange(int[] coins, int amount) {
  if (amount == 0) {
      return 0;
  }
  int dp[] = new int[amount + 1];
  for (int i = 1; i < dp.length; i++) {
      dp[i] = amount + 1;
  }
  for (int money = 1; money <= amount; money++) {
      for (int i = 0; i < coins.length; i++) {
          if (coins[i] <= money) {
              dp[money] = Math.min(dp[money], dp[money - coins[i]] + 1);
          }
      }
  }
  if (dp[amount] == (amount + 1)) {
      return -1;
  }
  return dp[amount];
}

5. 效率

执行用时 :14 ms, 在所有 Java 提交中击败了96.87%的用户
内存消耗 :35.7 MB, 在所有 Java 提交中击败了95.35%的用户