diff --git a/problems/0001.两数之和.md b/problems/0001.两数之和.md
index 8551274c..22b2e7eb 100644
--- a/problems/0001.两数之和.md
+++ b/problems/0001.两数之和.md
@@ -186,6 +186,24 @@ var twoSum = function (nums, target) {
 };
 ```
 
+TypeScript：
+
+```typescript
+function twoSum(nums: number[], target: number): number[] {
+    let helperMap: Map<number, number> = new Map();
+    let index: number | undefined;
+    let resArr: number[] = [];
+    for (let i = 0, length = nums.length; i < length; i++) {
+        index = helperMap.get(target - nums[i]);
+        if (index !== undefined) {
+            resArr = [i, index];
+        }
+        helperMap.set(nums[i], i);
+    }
+    return resArr;
+};
+```
+
 php
 
 ```php
diff --git a/problems/0347.前K个高频元素.md b/problems/0347.前K个高频元素.md
index 0b8fd2d7..8bd774e9 100644
--- a/problems/0347.前K个高频元素.md
+++ b/problems/0347.前K个高频元素.md
@@ -142,7 +142,7 @@ class Solution {
 
         Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
         // 根据map的value值正序排，相当于一个小顶堆
-        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>((o1, o2) -> o2.getValue() - o1.getValue());
+        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>((o1, o2) -> o1.getValue() - o2.getValue());
         for (Map.Entry<Integer, Integer> entry : entries) {
             queue.offer(entry);
             if (queue.size() > k) {
diff --git a/problems/0454.四数相加II.md b/problems/0454.四数相加II.md
index 6e916608..a7c903eb 100644
--- a/problems/0454.四数相加II.md
+++ b/problems/0454.四数相加II.md
@@ -192,8 +192,33 @@ var fourSumCount = function(nums1, nums2, nums3, nums4) {
 };
 ```
 
+TypeScript：
+
+```typescript
+function fourSumCount(nums1: number[], nums2: number[], nums3: number[], nums4: number[]): number {
+    let helperMap: Map<number, number> = new Map();
+    let resNum: number = 0;
+    let tempVal: number | undefined;
+    for (let i of nums1) {
+        for (let j of nums2) {
+            tempVal = helperMap.get(i + j);
+            helperMap.set(i + j, tempVal ? tempVal + 1 : 1);
+        }
+    }
+    for (let k of nums3) {
+        for (let l of nums4) {
+            tempVal = helperMap.get(0 - (k + l));
+            if (tempVal) {
+                resNum += tempVal;
+            }
+        }
+    }
+    return resNum;
+};
+```
 
 PHP:
+
 ```php
 class Solution {
     /**
diff --git a/problems/0583.两个字符串的删除操作.md b/problems/0583.两个字符串的删除操作.md
index d2f7d84b..53c1a125 100644
--- a/problems/0583.两个字符串的删除操作.md
+++ b/problems/0583.两个字符串的删除操作.md
@@ -18,6 +18,8 @@
 
 ## 思路 
 
+### 动态规划一
+
 本题和[动态规划：115.不同的子序列](https://programmercarl.com/0115.不同的子序列.html)相比，其实就是两个字符串都可以删除了，情况虽说复杂一些，但整体思路是不变的。
 
 这次是两个字符串可以相互删了，这种题目也知道用动态规划的思路来解，动规五部曲，分析如下：
@@ -98,6 +100,29 @@ public:
 
 ```
 
+### 动态规划二
+
+本题和[动态规划：1143.最长公共子序列](https://programmercarl.com/1143.最长公共子序列.html)基本相同，只要求出两个字符串的最长公共子序列长度即可，那么除了最长公共子序列之外的字符都是必须删除的，最后用两个字符串的总长度减去两个最长公共子序列的长度就是删除的最少步数。
+
+代码如下：
+
+```CPP
+class Solution {
+public:
+    int minDistance(string word1, string word2) {
+        vector<vector<int>> dp(word1.size()+1, vector<int>(word2.size()+1, 0));
+        for (int i=1; i<=word1.size(); i++){
+            for (int j=1; j<=word2.size(); j++){
+                if (word1[i-1] == word2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
+                else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
+            }
+        }
+        return word1.size()+word2.size()-dp[word1.size()][word2.size()]*2;
+    }
+};
+
+```
+
 ## 其他语言版本
 
 
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 45b576e7..4beed650 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -116,19 +116,19 @@ Java：
 ```Java
 // 前序遍历·递归·LC144_二叉树的前序遍历
 class Solution {
-    ArrayList<Integer> preOrderReverse(TreeNode root) {
-        ArrayList<Integer> result = new ArrayList<Integer>();
-        preOrder(root, result);
+    public List<Integer> preorderTraversal(TreeNode root) {
+        List<Integer> result = new ArrayList<Integer>();
+        preorder(root, result);
         return result;
     }
 
-    void preOrder(TreeNode root, ArrayList<Integer> result) {
+    public void preorder(TreeNode root, List<Integer> result) {
         if (root == null) {
             return;
         }
-        result.add(root.val);           // 注意这一句
-        preOrder(root.left, result);
-        preOrder(root.right, result);
+        result.add(root.val);
+        preorder(root.left, result);
+        preorder(root.right, result);
     }
 }
 // 中序遍历·递归·LC94_二叉树的中序遍历
diff --git a/problems/背包问题理论基础完全背包.md b/problems/背包问题理论基础完全背包.md
index 3cc8557c..f79310b8 100644
--- a/problems/背包问题理论基础完全背包.md
+++ b/problems/背包问题理论基础完全背包.md
@@ -52,7 +52,7 @@ for(int i = 0; i < weight.size(); i++) { // 遍历物品
 ```CPP
 // 先遍历物品，再遍历背包
 for(int i = 0; i < weight.size(); i++) { // 遍历物品
-    for(int j = weight[i]; j < bagWeight ; j++) { // 遍历背包容量
+    for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
         dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
 
     }