feat: 增加动态规划的跳转链接

Author: lucifer

problems/139.word-break.md

@@ -1,4 +1,3 @@
-
 ## 题目地址
 
 https://leetcode.com/problems/word-break/description/
@@ -32,28 +31,27 @@ Output: false
 
 ## 前置知识
 
-- 动态规划
+- [动态规划](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)
 
 ## 思路
 
 这道题是给定一个字典和一个句子，判断该句子是否可以由字典里面的单词组出来，一个单词可以用多次。
 
 暴力的方法是无解的，复杂度极其高。 我们考虑其是否可以拆分为小问题来解决。
-对于问题`(s, wordDict)` 我们是否可以用(s', wordDict) 来解决。 其中s' 是s 的子序列，
-当s'变成寻常(长度为0)的时候问题就解决了。 我们状态转移方程变成了这道题的难点。
+对于问题`(s, wordDict)` 我们是否可以用(s', wordDict) 来解决。 其中 s' 是 s 的子序列，
+当 s'变成寻常(长度为 0)的时候问题就解决了。 我们状态转移方程变成了这道题的难点。
 
-我们可以建立一个数组dp, dp[i]代表 字符串 s.substring(0, i) 能否由字典里面的单词组成，
-值得注意的是，这里我们无法建立dp[i] 和 dp[i - 1] 的关系，
-我们可以建立的是dp[i - word.length] 和 dp[i] 的关系。
+我们可以建立一个数组 dp, dp[i]代表 字符串 s.substring(0, i) 能否由字典里面的单词组成，
+值得注意的是，这里我们无法建立 dp[i] 和 dp[i - 1] 的关系，
+我们可以建立的是 dp[i - word.length] 和 dp[i] 的关系。
 
 我们用图来感受一下：
 
 ![139.word-break-1](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlu370c2hj30n60cnmy6.jpg)
 
-
 没有明白也没有关系，我们分步骤解读一下：
 
-（以下的图左边都代表s，右边都是dict，灰色代表没有处理的字符，绿色代表匹配成功，红色代表匹配失败）
+（以下的图左边都代表 s，右边都是 dict，灰色代表没有处理的字符，绿色代表匹配成功，红色代表匹配失败）
 
 ![139.word-break-2](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlu37ydiwj30aw0b1mxc.jpg)
 
@@ -63,7 +61,6 @@ Output: false
 
 ![139.word-break-5](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlu3qr7ppj30n90kqabg.jpg)
 
-
 上面分步解释了算法的基本过程，下面我们感性认识下这道题，我把它比喻为
 你正在`往一个老式手电筒🔦中装电池`
 
@@ -129,15 +126,15 @@ Output: false
  * @param {string[]} wordDict
  * @return {boolean}
  */
-var wordBreak = function(s, wordDict) {
+var wordBreak = function (s, wordDict) {
   const dp = Array(s.length + 1);
   dp[0] = true;
   for (let i = 0; i < s.length + 1; i++) {
     for (let word of wordDict) {
       if (word.length <= i && dp[i - word.length]) {
-          if (s.substring(i - word.length, i) === word) {
-            dp[i] = true;
-          }
+        if (s.substring(i - word.length, i) === word) {
+          dp[i] = true;
+        }
       }
     }
   }

problems/198.house-robber.md

@@ -26,8 +26,8 @@ Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (m
 
 ## 前置知识
 
-- 动态规划
-  
+- [动态规划](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)
+
 ## 思路
 
 这是一道非常典型且简单的动态规划问题，但是在这里我希望通过这个例子，
@@ -81,7 +81,7 @@ return b;
 
 ## 代码
 
-* 语言支持：JS，C++，Python
+- 语言支持：JS，C++，Python
 
 JavaScript Code：
 
@@ -133,7 +133,7 @@ JavaScript Code：
  * @param {number[]} nums
  * @return {number}
  */
-var rob = function(nums) {
+var rob = function (nums) {
   // Tag: DP
   const dp = [];
   dp[0] = 0;
@@ -149,7 +149,7 @@ var rob = function(nums) {
 
 C++ Code：
 
-> 与JavaScript代码略有差异，但状态迁移方程是一样的。
+> 与 JavaScript 代码略有差异，但状态迁移方程是一样的。
 
 ```C++
 class Solution {

problems/309.best-time-to-buy-and-sell-stock-with-cooldown.md

@@ -20,8 +20,8 @@ Explanation: transactions = [buy, sell, cooldown, buy, sell]
 
 ## 前置知识
 
-- 动态规划
-  
+- [动态规划](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)
+
 ## 思路
 
 这是一道典型的 DP 问题， DP 问题的核心是找到状态和状态转移方程。
@@ -77,7 +77,7 @@ sell[i]对应第 i 的 action 只能是 sell 或者 cooldown。
  * @param {number[]} prices
  * @return {number}
  */
-var maxProfit = function(prices) {
+var maxProfit = function (prices) {
   if (prices == null || prices.length <= 1) return 0;
 
   // 定义状态变量

problems/322.coin-change.md

@@ -1,15 +1,16 @@
-
 ## 题目地址
+
 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 
+Output: 3
 Explanation: 11 = 5 + 5 + 1
 Example 2:
 
@@ -23,11 +24,11 @@ You may assume that you have an infinite number of each kind of coin.
 ## 前置知识
 
 - 贪心算法
-  
-## 思路
+- [动态规划](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)
 
+## 思路
 
-假如我们把coin逆序排列，然后逐个取，取到刚好不大于amout，依次类推。
+假如我们把 coin 逆序排列，然后逐个取，取到刚好不大于 amout，依次类推。
 
 ```
 eg: 对于 [1,2,5] 组成 11 块
@@ -51,7 +52,7 @@ eg: 对于 [1,2,5] 组成 11 块
 因此结果是 3
 ```
 
-熟悉贪心算法的同学应该已经注意到了，这就是贪心算法，贪心算法更amount尽快地变得更小。
+熟悉贪心算法的同学应该已经注意到了，这就是贪心算法，贪心算法更 amount 尽快地变得更小。
 `经验表明，贪心策略是正确的`。 注意，我说的是经验表明， 贪心算法也有可能出错。 就拿这道题目来说，
 他也是不正确的！ 比如 `coins = [1, 5, 11] amout = 15`, 因此这种做法有时候不靠谱，我们还是采用靠谱的做法.
 
@@ -84,58 +85,60 @@ class Solution:
                     dp[i][j] = dp[i][j - 1]
 
         return -1 if dp[-1][-1] == amount + 1 else dp[-1][-1]
- ```
- 
- **复杂度分析**
+```
+
+**复杂度分析**
+
 - 时间复杂度：$O(amonut * len(coins))$
 - 空间复杂度：$O(amount * len(coins))$
 
-dp[i][j] 依赖于` dp[i][j - 1]`和 `dp[i - coins[j - 1]][j] + 1)` 这是一个优化的信号，我们可以将其优化到一维,具体见下方。
+dp[i][j] 依赖于`dp[i][j - 1]`和 `dp[i - coins[j - 1]][j] + 1)` 这是一个优化的信号，我们可以将其优化到一维,具体见下方。
+
 ## 关键点解析
 
 - 动态规划
 
 - 子问题
 
-用dp[i] 来表示组成i块钱，需要最少的硬币数，那么
+用 dp[i] 来表示组成 i 块钱，需要最少的硬币数，那么
 
-1. 第j个硬币我可以选择不拿       这个时候， 硬币数 =  dp[i]
+1. 第 j 个硬币我可以选择不拿 这个时候， 硬币数 = dp[i]
 
-2. 第j个硬币我可以选择拿     这个时候， 硬币数 =  dp[i - coins[j]] + 1
+2. 第 j 个硬币我可以选择拿 这个时候， 硬币数 = dp[i - coins[j]] + 1
 
 - 和背包问题不同， 硬币是可以拿任意个
 
 - 对于每一个 dp[i] 我们都选择遍历一遍 coin， 不断更新 dp[i]
 
 ## 代码
 
-
-* 语言支持：JS，C++,Python3
+- 语言支持：JS，C++,Python3
 
 JavaScript Code：
-```js
 
-var coinChange = function(coins, amount) {
-    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);
-        }
+```js
+var coinChange = function (coins, amount) {
+  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];
-
-
+  return dp[dp.length - 1] === Number.MAX_VALUE ? -1 : dp[dp.length - 1];
 };
 ```
+
 C++ Code：
-> C++中采用INT_MAX，因此判断时需要加上`dp[a - coin] < INT_MAX`以防止溢出
+
+> C++中采用 INT_MAX，因此判断时需要加上`dp[a - coin] < INT_MAX`以防止溢出
+
 ```C++
 class Solution {
 public:
@@ -171,10 +174,10 @@ class Solution:
 ```
 
 **复杂度分析**
+
 - 时间复杂度：$O(amonut * len(coins))$
 - 空间复杂度：$O(amount)$
 
-
 ## 扩展
 
 这是一道很简单描述的题目， 因此很多时候会被用到大公司的电面中。

problems/416.partition-equal-subset-sum.md

@@ -30,8 +30,8 @@
 ## 前置知识
 
 - DFS
-- 动态规划
- 
+- [动态规划](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)
+
 ### 思路
 
 抽象能力不管是在工程还是算法中都占据着绝对重要的位置。比如上题我们可以抽象为：

problems/518.coin-change-2.md

@@ -36,7 +36,7 @@ https://leetcode-cn.com/problems/coin-change-2/description/
 
 ## 前置知识
 
-- 动态规划
+- [动态规划](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)
 - 背包问题
 
 ## 思路
@@ -65,7 +65,7 @@ https://leetcode-cn.com/problems/coin-change-2/description/
 
 2. 第 j 个硬币我可以选择拿 这个时候， 组成数 = dp[i - coins[j]] + dp[i]
 
-- 和01背包问题不同， 硬币是可以拿任意个，属于完全背包问题
+- 和 01 背包问题不同， 硬币是可以拿任意个，属于完全背包问题
 
 - 对于每一个 dp[i] 我们都选择遍历一遍 coin， 不断更新 dp[i]
 
@@ -122,10 +122,8 @@ return dp[dp.length - 1];
 
 ## 代码
 
-
 代码支持：Python3，JavaScript：
 
-
 JavaSCript Code:
 
 ```js
@@ -140,7 +138,7 @@ JavaSCript Code:
  * @param {number[]} coins
  * @return {number}
  */
-var change = function(amount, coins) {
+var change = function (amount, coins) {
   if (amount === 0) return 1;
 
   const dp = [1].concat(Array(amount).fill(0));

problems/91.decode-ways.md

@@ -28,7 +28,7 @@ Explanation: It could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).
 ## 前置知识
 
 - 爬楼梯问题
-- 动态规划
+- [动态规划](https://github.com/azl397985856/leetcode/blob/master/thinkings/dynamic-programming.md)
 
 ## 思路