feat: 更新blog

Author: funnycoderstar

docs/algorithm/动态规划/不同的二叉搜索树.md

@@ -0,0 +1,49 @@
+
+## 题目描述
+
+<br />给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？<br />
+<br />示例:<br />
+
+```javascript
+输入: 3
+输出: 5
+解释:
+给定 n = 3, 一共有 5 种不同结构的二叉搜索树:
+
+   1         3     3      2      1
+    \       /     /      / \      \
+     3     2     1      1   3      2
+    /     /       \                 \
+   2     1         2                 3
+```
+
+## 解题方法
+
+- 每个树的构成都可以分为左子树和右子树，所以以 i 为根节点的二叉搜索树种类的个数可以分解为子问题：左子树的种类和右子树的种类
+- 左子树的节点范围：1...i-1
+- 右子树的节点范围：`i+1...n`
+- 那么就可以把同样的问题转接到左子树和右子树上。
+
+```javascript
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var numTrees = function (n) {
+ // dp[i]表示以1...i为节点组成的二叉搜索树的种类
+  let dp = new Array(n + 1).fill(0);
+  dp[0] = 1;
+  dp[1] = 1;
+  // dp[1]已经确定，因此从2开始
+  for (let i = 2; i <= n; i++) {
+    // j表示分别从1为根节点至i为根节点
+    for (let j = 1; j <= i ; j++) {
+      dp[i] += dp[j - 1] * dp[i - j];
+    }
+  }
+  return dp[n];
+};
+```
+
+- 时间复杂度：O(n<sup>2</sup>)
+- 空间复杂度：O(n)

docs/algorithm/动态规划/最长公共子序列.md

@@ -0,0 +1,101 @@
+# 最长重复子数组
+
+<a name="273a27cc"></a>
+## 题目描述
+
+<br />给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。<br />
+<br />示例 1:<br />
+<br />输入:<br />
+
+```javascript
+A: [1,2,3,2,1]
+B: [3,2,1,4,7]
+输出: 3
+解释: 
+长度最长的公共子数组是 [3, 2, 1]。
+```
+
+
+<a name="d04d69d9"></a>
+## 解题方法
+
+
+<a name="818f9b73"></a>
+### 方法一： 动态规划
+
+<br />暴力解法：<br />枚举数组 A 中的起始位置 i 与数组 B 中的起始位置 j , 然后计算 A[i:] 与 B[i:]的最长公共子数组长度 k。最终答案即为所有的重复子数组的长度的最大值。<br />
+
+> 这里借用 python 表示数组的方法， A[i:] 表示 数组 A 中索引 i 到数组末尾的范围对应的子数组。
+
+
+
+```javascript
+/**
+ * @param {number[]} A
+ * @param {number[]} B
+ * @return {number}
+ */
+var findLength = function (A, B) {
+  const m = A.length;
+  const n = B.length;
+  let res = 0;
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (A[i] == B[j]) {
+        // 遇到相同项
+        let subLen = 1; // 公共子序列长度至少为1
+        while (
+          A[i + subLen] == B[j + subLen] && // 它们下一项也相同
+          i + subLen < m && // 并且没有越界
+          j + subLen < n // 并且没有越界
+        ) {
+          subLen++; // 公共子序列长度每次增加 1，考察新的一项
+        }
+        res = Math.max(subLen, res);
+      }
+    }
+  }
+  return res;
+};
+```
+
+<br />暴力解法中，最快的情况就是 对于任意 i 与 j, A[i] 与 B[i] 比较了 min(i + 1, j + 1)次，这也是导致了该暴力解法时间复杂度过高的根本原因。<br />
+<br />举个简单的例子：数组A 是[1, 2, 3], 数组B 是[1, 2, 4]，那么在暴力解法中 A[2]与B[2]被比较了3次<br />
+
+1. 起始位置 i = 0，j = 0的时候，分别比较 A[0]和 B[0]， A[1]和B[1], A[2]和B[2]
+1. 起始位置 i = 1， j = 1 的时候，分别比较  A[1]和B[1], A[2]和B[2]
+1. 起始位置 i = 2， j = 2 的时候，分别比较  A[2]和B[2]
+
+
+<br />我们希望优化这过程，使得任意一对 A[i] 和 B[j]值被比较一次。我们很容易想到利用这一次的比较成果，如果 A[i] = B[j], 那么我们知道 A[i:]与 B[j:]的最长公共子数组长度为 A[i-1:]与 B[j-1:]的最长公共子数组长度 加 1，<br />
+
+```javascript
+/**
+ * @param {number[]} A
+ * @param {number[]} B
+ * @return {number}
+ */
+var findLength = function(A, B) {
+    // 初始化一个二维数组，每一项都是 0 
+    let m = A.length;
+    let n = B.length;
+    let dp = new Array(m + 1);
+    for(let i = 0; i <= m; i++) {
+        dp[i] = new Array(n + 1).fill(0);
+    }
+    let res = 0;
+    for(let i = 1; i <= m; i++) {
+        for(let j = 1; j <= n; j++) {
+            if(A[i - 1] === B[j - 1]) {
+                dp[i][j] = dp[i -1][j-1] + 1;
+            }
+            res = Math.max(dp[i][j], res)
+        }
+    }
+    return res;
+};
+```
+
+
+<a name="9d1d8581"></a>
+## 方法二：滑动窗口