update

Author: muyids

README.md

@@ -60,7 +60,7 @@ node script deploy.sh
 
 ## 🔐 Problems & Solutions
 
-完成进度（[948](./TOC-By-ID.md)🔑/ [2407](https://leetcode-cn.com/problemset/all/)🔒) 
+完成进度（[1011](./TOC-By-ID.md)🔑/ [2584](https://leetcode-cn.com/problemset/all/)🔒) 
 
 - 🔗 [标签查找](./TOC-By-Tag.md)
 

TOC-By-ID.md

@@ -1,14 +1,8 @@
-给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
 
-例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
 
-与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
+### 排序 + 双指针
 
-----
 
-思路
-
-排序 + 双指针
 
 本题目因为要计算三个数，如果靠暴力枚举的话时间复杂度会到 O(n^3)，需要降低时间复杂度
 
@@ -22,6 +16,41 @@
 
 总时间复杂度：O(logn) + O(n^2) = O(n^2)
 
+
+
+### 代码实现
+
+java
+
+```java
+class Solution {
+    public int threeSumClosest(int[] nums, int t) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int min = 0x3f3f3f3f;
+        int res = 0x3f3f3f3f;
+        for (int d = 0; d < n; d++) {
+            for (int i = d + 1, j = n - 1; i < j; ) {
+                int sum = nums[d] + nums[i] + nums[j];
+                if (Math.abs(sum - t) < min) {
+                    res = sum;
+                    min = Math.abs(sum - t);
+                }
+                if (sum > t) j--;
+                else i++;
+            }
+        }
+
+        return res;
+
+    }
+}
+```
+
+
+
+Javascript
+
 ```javascript
 var threeSumClosest = function (nums, target) {
     nums = nums.sort((a, b) => a - b)

TOC-By-Tag.md

@@ -49,15 +49,15 @@ public:
 
 dp问题思考方式
 
-1. 状态表示 f[i]
-    1. 集合 所有以i结尾的子序列
-    2. 属性：Max/Min/数量  f[i]的最大值
-2. 状态计算 -- 集合的划分 f(i) = Math.max(f(i-1)+ nums[i], 0)
+- 状态表示`f[i]`
+  - 所有以i结尾的子数组
+  - 属性：Max/Min/数量  `f[i]`的最大值
+- 状态计算
+  - `f(i) = Math.max(f(i-1)+ nums[i], 0)`
 
-### 代码实现
 
 
-cpp
+### 代码实现
 
 ```cpp
 class Solution {
@@ -71,3 +71,8 @@ public:
     }
 };
 ```
+
+
+
+
+

algorithms/1-100/16.3sum-closest.md

@@ -26,6 +26,20 @@
 ---
 
 
+
+## 算法思路
+
+
+
+- 定义方向 
+- 二维矩阵边界处理
+- 已遍历位置判断：floodfilled填充原矩阵标识
+
+
+
+javascript
+
+
 ```javascript
 var spiralOrder = function (matrix) {
     if (matrix.length == 0 || matrix[0].length == 0) return []
@@ -52,3 +66,33 @@ var spiralOrder = function (matrix) {
 };
 
 ```
+
+
+
+java
+
+```java
+class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        int[] d = {0, 1, 0, -1, 0}; // → ↓ ← ↑
+        List<Integer> ans = new ArrayList<>();
+        if (matrix.length == 0) return ans;
+        int m = matrix.length, n = matrix[0].length;
+        int i = 0, j = 0, dd = 0, cnt = m * n;
+        while (cnt-- > 0) {
+            ans.add(matrix[i][j]);
+            if ((i == 0 && dd == 3)
+                    || (i == m - 1 && dd == 1)
+                    || (j == 0 && dd == 2)
+                    || (j == n - 1 && dd == 0)
+                    || matrix[i + d[dd]][j + d[dd + 1]] == 101)
+                dd = (dd + 1) % 4;
+            matrix[i][j] = 101;
+            i += d[dd];
+            j += d[dd + 1];
+        }
+        return ans;
+    }
+}
+```
+

algorithms/1-100/53.maximum-subarray.md

@@ -0,0 +1,56 @@
+## 解题思路
+
+
+
+
+
+- 有向图的最长路
+  - 拓扑图 求最长路 => 递推
+- 判断单词s是t的前身
+  - s的长度 + 1 == t的长度
+  - s是t的子序列
+
+
+
+## 代码实现
+
+```java
+class Solution {
+
+    boolean check(String s, String t) {
+        if (s.length() + 1 != t.length()) return false;
+        int i = 0;
+        for (char c : t.toCharArray()) {
+            if (i <s.length() && s.charAt(i) == c) i++;
+        }
+        return i == s.length();
+    }
+
+    public int longestStrChain(String[] words) {
+        Arrays.sort(words, new Comparator<String>() {
+            @Override
+            public int compare(String o1, String o2) {
+                return o1.length() - o2.length();
+            }
+        });
+
+        int res = 1;
+
+        int n = words.length;
+        int[] f = new int[n];
+        Arrays.fill(f, 1);
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < i; j++) {
+                if (check(words[j], words[i])) {
+                    f[i] = Math.max(f[i], f[j] + 1);
+                }
+            }
+            res = Math.max(res, f[i]);
+        }
+        return res;
+    }
+
+}
+```
+

algorithms/1-100/54.spiral-matrix.md

@@ -0,0 +1 @@
+二分查找

algorithms/1001-1100/1048.longest-string-chain.md

@@ -2,25 +2,22 @@
 
 字符串表达式可以包含左括号 ( ，右括号 )，加号 + ，减号 -，非负整数和空格  。
 
-示例 1:
 
-输入: "1 + 1"
-输出: 2
-示例 2:
 
-输入: " 2-1 + 2 "
-输出: 3
-示例 3:
+----
 
-输入: "(1+(4+5+2)-3)+(6+8)"
-输出: 23
-说明：
 
-你可以假设所给定的表达式都是有效的。
-请不要使用内置的库函数 eval。
 
-来源：力扣（LeetCode）
-链接：https://leetcode-cn.com/problems/basic-calculator
-著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+### 双栈实现
 
-----
+
+
+一个栈 opStk 存放 操作符，一个栈 numStk存放 数字
+
+
+
+
+
+- '( '， ’+‘， ’-‘ 入栈
+- 数字，opStk出一个操作符，numStk出一个数字，与当前数字计算后，压  numStk
+- ’）‘操作符出栈

algorithms/1501-1600/1574.shortest-subarray-to-be-removed-to-make-array-sorted.md

@@ -22,26 +22,24 @@
 
 ## 哈希判重
 
-空间复杂度O(N)，违反了`只能使用额外的 O(1) 的空间`。
+空间复杂度O(N)，违反了`只能使用额外的 O(1) 的空间`的限制。
 
-## 抽屉原理
-
-数组中只有一个重复的数字，但它可能不止重复出现一次。
 
-把所有元素放在他的下标处，遇到位置已经被占用的就是所得元素。
-
-但是，违反了`不能更改原数组（假设数组是只读的）`。
 
 ## 求和
 
 本题只有一个重复元素，但是重复次数不确定，不能求和
 
+
+
 ## 位运算
 
 根据两个相同元素异或结果为0
 
 重复次数不一定为偶数，不能使用异或
 
+
+
 ## 先排序，再比较相邻元素
 
 改变了原数组
@@ -55,25 +53,41 @@ var findDuplicate = function (nums) {
 };
 ```
 
-## 二分法(分治 + 抽屉原理)
+
+
+## 抽屉原理
+
+数组中只有一个重复的数字，但它可能不止重复出现一次。
+
+把所有元素放在他的下标处，遇到位置已经被占用的就是所得元素。
+
+但是，违反了`不能更改原数组（假设数组是只读的）`。
+
+
+
+## 二分查找
+
+
 
 这道题目主要应用了抽屉原理和分治的思想。
 
 抽屉原理：n+1 个苹果放在 n 个抽屉里，那么至少有一个抽屉中会放两个苹果。
 
 用在这个题目中就是，一共有 n+1 个数，每个数的取值范围是1到n，所以至少会有一个数出现两次。
 
-然后用分治的思想，将数的取值范围[1, n]划分成[1, n/2]和[n/2+1, n]两个子区间，然后分别统计两个区间中数的个数。
+然后用分治的思想，将数的取值范围`[1, n]`划分成`[1, n/2]`和`[n/2+1, n]`两个子区间，然后分别统计两个区间中数的个数。
 
-如果[1, n/2]中数的个数超过区间长度，结果就在这个区间中，否则在[n/2+1, n]区间中
+如果`[1, n/2]`中数的个数超过区间长度，结果就在这个区间中，否则在`[n/2+1, n]`区间中
 
 依次类推，每次我们可以把区间长度缩小一半，直到区间长度为1时，我们就找到了答案。
 
-复杂度分析
 
-时间复杂度：每次会将区间长度缩小一半，一共会缩小 O(logn) 次。每次统计两个子区间中的数时需要遍历整个数组，时间复杂度是 O(n)。所以总时间复杂度是 O(nlogn)。
 
-空间复杂度：代码中没有用到额外的数组，所以额外的空间复杂度是 O(1)。
+#### 复杂度分析
+
+时间复杂度：每次会将区间长度缩小一半，一共会缩小 `O(logn)` 次。每次统计两个子区间中的数时需要遍历整个数组，时间复杂度是 `O(n)`。所以总时间复杂度是 `O(nlogn)`。
+
+空间复杂度：代码中没有用到额外的数组，所以额外的空间复杂度是 `O(1)`。
 
 ```cpp
 class Solution {