feat: dp

322.coin-change.js → problems/322.coin-change.md

+
+## 题目地址
+https://leetcode.com/problems/coin-change/description/
+
+## 题目描述
+```
+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
+Note:
+You may assume that you have an infinite number of each kind of coin.
+
+```
+## 思路
+
+可以用动态规划来写， 可以先画一个二维表，然后观察，其是否可以用一维表代替。
+
+也可以暴力分析，我们把coin逆序排列，然后逐个取，取到刚好不大于amout，依次类推。
+
+```
+eg: 对于 [1,2,5] 组成 11 块
+
+- 排序[5,2,1]
+
+- 取第一个5, 更新amout 为 11 - 5 = 6 (1⃣️)
+      6 > 5 继续更新 为 6 - 5 = 1 (2⃣️)
+      1 < 5 退出
+
+- 取第二个2
+      1 < 2 退出
+
+- 取最后一个元素，也就是1
+
+      1 === 1 更新为 1 - 1 = 0 (3⃣️)
+
+- amout 为 0 退出
+
+
+因此结果是 3
+```
+## 关键点解析
+
+- 动态规划
+
+- 子问题
+
+用dp[i] 来表示组成i块钱，需要最少的硬币数，那么
+
+1. 第j个硬币我可以选择不拿       这个时候， 硬币数 =  dp[i]
+
+2. 第j个硬币我可以选择拿     这个时候， 硬币数 =  dp[i - coins[j]] + 1
+
+- 和背包问题不同， 硬币是可以拿任意个
+
+- 对于每一个 dp[i] 我们都选择遍历一遍 coin， 不断更新 dp[i]
+
+## 代码
+```js
 /*
  * @lc app=leetcode id=322 lang=javascript
  *
@@ -40,39 +106,26 @@
  * @return {number}
  */
 
-// coinChange([1,2,5], 11) =
-//   (coinChange([1,2], 6) + 1, coinChange([1,2], 1) + 2)
 var coinChange = function(coins, amount) {
-  //   if (amount === 0) {
-  //     return 0;
-  //   }
-  //   if (amount < Math.min(...coins)) return -1;
-  //   const dp = Array(amount + 1);
-  //   for (let i = 0; i < dp.length; i++) {
-  //     dp[i] = Number.MAX_VALUE;
-  //   }
-  //   dp[0] = 0;
-  //   for (let i = 1; i < dp.length; i++) {
-  //     for (let j = 0; j < coins.length; j++) {
-  //       if (i - coins[j] >= 0) {
-  //         dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
-  //       }
-  //     }
-  //   }
-
-  //   return dp[dp.length - 1] === Number.MAX_VALUE ? -1 : dp[dp.length - 1];
-  // [186,419,83,408]\n6249
-  if (amount === 0) return 0;
-
-  const sortedCoins = coins.sort((a, b) => b - a);
-
-  if (sortedCoins[sortedCoins.length - 1] > amount) return -1;
-
-  const count = Math.floor(amount / sortedCoins[0]);
-  const result = coinChange(
-    sortedCoins.slice(1),
-    amount - count * sortedCoins[0]
-  );
-
-  return count + (result === -1 ? 0 : result);
+    if (amount === 0) {
+      return 0;
+    }
+    const dp = Array(amount + 1).fill(Number.MAX_VALUE)
+    dp[0] = 0;
+    for (let i = 1; i < dp.length; i++) {
+      for (let j = 0; j < coins.length; j++) {
+        if (i - coins[j] >= 0) {
+          dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
+        }
+      }
+    }
+
+    return dp[dp.length - 1] === Number.MAX_VALUE ? -1 : dp[dp.length - 1];
+
+
 };
+```
+
+## 扩展
+
+这是一道很简单描述的题目， 很多是否会被用到大公司的电面中。

thinkings/dynamic-programming.md

@@ -135,6 +135,28 @@ f(n) = f(n-1) + f(n-2) 就是【状态转移公式】
 
 ```
 
+### 动态规划为什么要画表格
+
+动态规划问题要画表格，但是有的人不知道为什么要画，就觉得这个是必然的，必要要画表格才是动态规划。
+
+其实动态规划本质上是将大问题转化为小问题，然后大问题的解是和小问题有关联的，换句话说大问题可以由小问题进行计算得到。
+
+这一点是和递归一样的， 但是动态规划是一种类似查表的方法来缩短时间复杂度和空间复杂度。
+
+画表格的目的就是去不断推导，完成状态转移， 表格中的每一个cell都是一个`小问题`， 我们填表的过程其实就是在解决问题的过程，
+我们先解决规模为寻常的情况，然后根据这个结果逐步推导，通常情况下，表格的右下角是问题的最大的规模，也就是我们想要求解的规模。
+
+比如我们用动态规划解决背包问题， 其实就是在不断根据之前的小问题`A[i - 1][j] A[i -1][w - wj]`来询问：
+
+1. 我是应该选择它
+2. 还是不选择它
+
+至于判断的标准很简单，就是价值最大，因此我们要做的就是对于选择和不选择两种情况分别求价值，然后取最大，最后更新cell即可。
+
+### 相关问题
+
+[硬币找零问题](../problems/322.coin-change.md)
+
 ## 总结
 
 本篇文章总结了算法中比较常用的两个方法 - 递归和动态规划。