no message

Author: ligecarryme

入门/经典算法TS实现.md

@@ -110,8 +110,8 @@ const mergeSort = (nums: number[], left: number, right: number) => {
 
 ```tsx
 const quickSort = (nums: number[], start: number, end: number) => {
-  let left = start,
-    right = end
+  let left = start
+  let right = end
   const pivot = nums[start]
   while (left < right) {
     while (left < right && nums[right] > pivot) {
@@ -123,7 +123,7 @@ const quickSort = (nums: number[], start: number, end: number) => {
     if (nums[left] === nums[right] && left < right) {
       left++
     } else {
-      ;[nums[left], nums[right]] = [nums[right], nums[left]]
+      [nums[left], nums[right]] = [nums[right], nums[left]]
     }
   }
   if (start < left - 1) {

基础算法篇/动态规划.md

@@ -79,7 +79,7 @@ console.log(minimumTotal(tringle)); //11
 
 `f(i,j)=min(f(i+1,j),f(i+1,j+1))+triangle[i][j]`
 
-```js
+```tsx
 var minimumTotal = function(tringle){
     let row = tringle.length;
     let dp = new Array(row+1).fill(0);
@@ -90,6 +90,20 @@ var minimumTotal = function(tringle){
     }
     return dp[0];
 }
+
+function minimumTotal(triangle: number[][]): number {  // 时间、空间复杂度O（n2）
+    const len = triangle.length
+    const ans: number[][] = new Array(len).fill(0).map(() => new Array(len).fill(0))
+    ans[0][0] = triangle[0][0]
+    for (let i = 1; i < len; i++) {
+        ans[i][0] = ans[i - 1][0] + triangle[i][0]
+        for (let j = 1; j < triangle[i].length; j++) {
+            ans[i][j] = Math.min(ans[i - 1][j], ans[i - 1][j - 1]) + triangle[i][j]
+        }
+        ans[i][i] = ans[i - 1][i - 1] + triangle[i][i]
+    }
+    return Math.min(...ans[len - 1])
+};
 ```
 
 ## 递归和动规关系
@@ -104,7 +118,7 @@ Function(x) {
 }
 ```
 
-动态规划：是一种解决问题的思想，大规模问题的结果，是由小规模问 题的结果运算得来的。动态规划可用递归来实现(Memorization Search)
+动态规划：是一种解决问题的思想，大规模问题的结果，是由小规模问题的结果运算得来的。动态规划可用递归来实现(Memorization Search)。
 
 ## 使用场景
 
@@ -127,7 +141,7 @@ Function(x) {
 2. 方程 Function
    - 状态之间的联系，怎么通过小的状态，来算大的状态
 3. 初始化 Intialization
-   - 最极限的小状态是什么, 起点
+   - 最极限的小状态是什么， 起点
 4. 答案 Answer
    - 最大的那个状态是什么，终点
 
@@ -299,14 +313,6 @@ function jump(nums: number[]): number {  //从前往后推
 
 给你一个字符串 `s`，请你将 `s` 分割成一些子串，使每个子串都是回文。返回符合要求的 最少分割次数 。
 
-```tsx
-
-```
-
-##### [300. 最长递增子序列](https://leetcode-cn.com/problems/longest-increasing-subsequence/)
-
-给你一个整数数组 `nums` ，找到其中最长严格递增子序列的长度。
-
 ##### [300. 最长递增子序列](https://leetcode-cn.com/problems/longest-increasing-subsequence/)
 
 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。