diff --git a/problems/0020.有效的括号.md b/problems/0020.有效的括号.md
index 77c6e10a..98cc7cd8 100644
--- a/problems/0020.有效的括号.md
+++ b/problems/0020.有效的括号.md
@@ -162,6 +162,33 @@ class Solution {
         return deque.isEmpty();
     }
 }
+// 方法2
+class Solution {
+    public boolean isValid(String s) {
+
+        Stack<Character> stack = new Stack<>();
+        Map<Character, Character> map = new HashMap<Character, Character>() {
+            {
+                put('}', '{');
+                put(']', '[');
+                put(')', '(');
+            }
+        };
+
+        for (Character c : s.toCharArray()) {               // 顺序读取字符
+            if (!stack.isEmpty() && map.containsKey(c)) {   // 是右括号 && 栈不为空
+                if (stack.peek() == map.get(c)) {               // 取其对应的左括号直接和栈顶比
+                    stack.pop();                                // 相同则抵消，出栈
+                } else {        
+                    return false;                               // 不同则直接返回
+                }
+            } else {                                
+                stack.push(c);                              // 左括号，直接入栈
+            }
+        }
+        return stack.isEmpty();                             // 看左右是否抵消完
+    }
+}
 ```
 
 Python：
diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
index 58cd3d8a..132d65bb 100644
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@@ -86,7 +86,9 @@ public:
 
 
 Java：
+
 ```Java
+// 递归版本
 class Solution {
     public ListNode swapPairs(ListNode head) {
         // base case 退出提交
@@ -104,6 +106,27 @@ class Solution {
 } 
 ```
 
+```java
+// 虚拟头结点
+class Solution {
+  public ListNode swapPairs(ListNode head) {
+
+    ListNode dummyNode = new ListNode(0);
+    dummyNode.next = head;
+    ListNode prev = dummyNode;
+
+    while (prev.next != null && prev.next.next != null) {
+      ListNode temp = head.next.next; // 缓存 next
+      prev.next = head.next;          // 将 prev 的 next 改为 head 的 next
+      head.next.next = head;          // 将 head.next(prev.next) 的next，指向 head
+      head.next = temp;               // 将head 的 next 接上缓存的temp
+      prev = head;                    // 步进1位
+      head = head.next;               // 步进1位
+    }
+    return dummyNode.next;
+  }
+}
+```
 
 Python：
 
diff --git a/problems/0045.跳跃游戏II.md b/problems/0045.跳跃游戏II.md
index b8e369e6..f65ceb9e 100644
--- a/problems/0045.跳跃游戏II.md
+++ b/problems/0045.跳跃游戏II.md
@@ -175,7 +175,22 @@ class Solution {
 ```
 
 Python：
-
+```python
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        if len(nums) == 1: return 0
+        ans = 0
+        curDistance = 0
+        nextDistance = 0
+        for i in range(len(nums)):
+            nextDistance = max(i + nums[i], nextDistance)
+            if i == curDistance: 
+                if curDistance != len(nums) - 1:
+                    ans += 1
+                    curDistance = nextDistance
+                    if nextDistance >= len(nums) - 1: break
+        return ans
+```
 
 Go：
 
diff --git a/problems/0046.全排列.md b/problems/0046.全排列.md
index d177e391..89ad00cc 100644
--- a/problems/0046.全排列.md
+++ b/problems/0046.全排列.md
@@ -149,6 +149,7 @@ public:
 Java：
 ```java
 class Solution {
+
     List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
     LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
     boolean[] used;
@@ -167,9 +168,6 @@ class Solution {
             return;
         }
         for (int i = 0; i < nums.length; i++){
-            // if (path.contains(nums[i])){
-            //     continue;
-            // }
             if (used[i]){
                 continue;
             }
diff --git a/problems/0070.爬楼梯.md b/problems/0070.爬楼梯.md
index f0a08f99..6cbd6299 100644
--- a/problems/0070.爬楼梯.md
+++ b/problems/0070.爬楼梯.md
@@ -212,7 +212,45 @@ public:
 
 
 Java：
+```Java
+class Solution {
+    public int climbStairs(int n) {
+        // 跟斐波那契数列一样
+        if(n <= 2) return n;
+        int a = 1, b = 2, sum = 0;
+        
+        for(int i = 3; i <= n; i++){
+            sum = a + b;
+            a = b;
+            b = sum;
+        }
+        return b;
+    }
+}
+```
 
+```java
+// 常规方式
+public int climbStairs(int n) {
+    int[] dp = new int[n + 1];
+    dp[0] = 1;
+    dp[1] = 1;
+    for (int i = 2; i <= n; i++) {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    return dp[n];
+}
+// 用变量记录代替数组
+public int climbStairs(int n) {
+    int a = 0, b = 1, c = 0; // 默认需要1次
+    for (int i = 1; i <= n; i++) {
+        c = a + b;          // f(i - 1) + f(n - 2)
+        a = b;              // 记录上一轮的值
+        b = c;              // 向后步进1个数
+    }
+    return c;
+}
+```
 
 Python：
 
diff --git a/problems/0098.验证二叉搜索树.md b/problems/0098.验证二叉搜索树.md
index f246c21a..d8945eff 100644
--- a/problems/0098.验证二叉搜索树.md
+++ b/problems/0098.验证二叉搜索树.md
@@ -304,6 +304,35 @@ class Solution {
         return true;
     }
 }
+
+// 简洁实现·递归解法
+class Solution {
+    public boolean isValidBST(TreeNode root) {
+        return validBST(Long.MIN_VALUE, Long.MAX_VALUE, root);
+    }
+    boolean validBST(long lower, long upper, TreeNode root) {
+        if (root == null) return true;
+        if (root.val <= lower || root.val >= upper) return false;
+        return validBST(lower, root.val, root.left) && validBST(root.val, upper, root.right);
+    }
+}
+// 简洁实现·中序遍历
+class Solution {
+    private long prev = Long.MIN_VALUE;
+    public boolean isValidBST(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        if (!isValidBST(root.left)) {
+            return false;
+        }
+        if (root.val <= prev) { // 不满足二叉搜索树条件
+            return false;
+        }
+        prev = root.val;
+        return isValidBST(root.right);
+    }
+}
 ```
 
 Python：
diff --git a/problems/0112.路径总和.md b/problems/0112.路径总和.md
index 1b75113e..ecbefd90 100644
--- a/problems/0112.路径总和.md
+++ b/problems/0112.路径总和.md
@@ -332,6 +332,19 @@ class Solution {
     }
 }
 
+// LC112 简洁方法
+class Solution {
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        
+        if (root == null) return false; // 为空退出
+        
+        // 叶子节点判断是否符合
+        if (root.left == null && root.right == null) return root.val == targetSum;
+
+        // 求两侧分支的路径和
+        return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
+    }
+}
 ```
 
 Python：
diff --git a/problems/0121.买卖股票的最佳时机.md b/problems/0121.买卖股票的最佳时机.md
index 3d564892..a0b35090 100644
--- a/problems/0121.买卖股票的最佳时机.md
+++ b/problems/0121.买卖股票的最佳时机.md
@@ -198,7 +198,22 @@ public:
 
 
 Java：
-
+```java
+class Solution {
+    public int maxProfit(int[] prices) {
+        int minprice = Integer.MAX_VALUE;
+        int maxprofit = 0;
+        for (int i = 0; i < prices.length; i++) {
+            if (prices[i] < minprice) {
+                minprice = prices[i];
+            } else if (prices[i] - minprice > maxprofit) {
+                maxprofit = prices[i] - minprice;
+            }
+        }
+        return maxprofit;
+    }
+}
+```
 
 Python：
 
diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
index 3444ca73..c85272bc 100644
--- a/problems/0122.买卖股票的最佳时机II（动态规划）.md
+++ b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -133,7 +133,34 @@ public:
 
 
 Java：
+```java
+// 动态规划
+class Solution 
+    public int maxProfit(int[] prices) {
+        int n = prices.length;
+        int[][] dp = new int[n][2];
+        dp[0][0] = 0;
+        dp[0][1] = -prices[0];
+        for (int i = 1; i < n; ++i) {
+            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
+            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
+        }
+        return dp[n - 1][0];
+    }
 
+    public int maxProfit(int[] prices) {
+        int n = prices.length;
+        int dp0 = 0, dp1 = -prices[0];
+        for (int i = 1; i < n; ++i) {
+            int newDp0 = Math.max(dp0, dp1 + prices[i]);
+            int newDp1 = Math.max(dp1, dp0 - prices[i]);
+            dp0 = newDp0;
+            dp1 = newDp1;
+        }
+        return dp0;
+    }
+}
+```
 
 Python：
 
diff --git a/problems/0150.逆波兰表达式求值.md b/problems/0150.逆波兰表达式求值.md
index 4e7365f7..12977c39 100644
--- a/problems/0150.逆波兰表达式求值.md
+++ b/problems/0150.逆波兰表达式求值.md
@@ -170,7 +170,32 @@ public class EvalRPN {
 
 }
 ```
-
+Go:
+```Go
+func evalRPN(tokens []string) int {
+	stack := []int{}
+	for _, token := range tokens {
+		val, err := strconv.Atoi(token)
+		if err == nil {
+			stack = append(stack, val)
+		} else {
+			num1, num2 := stack[len(stack)-2], stack[(len(stack))-1]
+			stack = stack[:len(stack)-2]
+			switch token {
+			case "+":
+				stack = append(stack, num1+num2)
+			case "-":
+				stack = append(stack, num1-num2)
+			case "*":
+				stack = append(stack, num1*num2)
+			case "/":
+				stack = append(stack, num1/num2)
+			}
+		}
+	}
+	return stack[0]
+}
+```
 
 
 
diff --git a/problems/0198.打家劫舍.md b/problems/0198.打家劫舍.md
index c64648ad..649dd055 100644
--- a/problems/0198.打家劫舍.md
+++ b/problems/0198.打家劫舍.md
@@ -111,7 +111,24 @@ public:
 
 
 Java：
+```Java
+// 动态规划
+class Solution {
+	public int rob(int[] nums) {
+		if (nums == null || nums.length == 0) return 0;
+		if (nums.length == 1) return nums[0];
 
+		int[] dp = new int[nums.length + 1];
+		dp[0] = nums[0];
+		dp[1] = Math.max(dp[0], nums[1]);
+		for (int i = 2; i < nums.length; i++) {
+			dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+		}
+
+		return dp[nums.length - 1];
+	}
+}
+```
 
 Python：
 
diff --git a/problems/0213.打家劫舍II.md b/problems/0213.打家劫舍II.md
index 55e71bc0..fc58a065 100644
--- a/problems/0213.打家劫舍II.md
+++ b/problems/0213.打家劫舍II.md
@@ -98,7 +98,28 @@ public:
 
 
 Java：
+```Java
+class Solution {
+    public int rob(int[] nums) {
+        if (nums == null || nums.length == 0)
+            return 0;
+        int len = nums.length;
+        if (len == 1)
+            return nums[0];
+        return Math.max(robAction(nums, 0, len - 1), robAction(nums, 1, len));
+    }
 
+    int robAction(int[] nums, int start, int end) {
+        int x = 0, y = 0, z = 0;
+        for (int i = start; i < end; i++) {
+            y = z;
+            z = Math.max(y, x + nums[i]);
+            x = y;
+        }
+        return z;
+    }
+}
+```
 
 Python：
 
diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md
index 2bc5cf9c..1cdc48b9 100644
--- a/problems/0300.最长上升子序列.md
+++ b/problems/0300.最长上升子序列.md
@@ -110,7 +110,26 @@ public:
 
 
 Java：
-
+```Java
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        int[] dp = new int[nums.length];
+        Arrays.fill(dp, 1);
+        for (int i = 0; i < dp.length; i++) {
+            for (int j = 0; j < i; j++) {
+                if (nums[i] > nums[j]) {
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
+                }
+            }
+        }
+        int res = 0;
+        for (int i = 0; i < dp.length; i++) {
+            res = Math.max(res, dp[i]);
+        }
+        return res;
+    }
+}
+```
 
 Python：
 
diff --git a/problems/0337.打家劫舍III.md b/problems/0337.打家劫舍III.md
index 50b06e22..20eea817 100644
--- a/problems/0337.打家劫舍III.md
+++ b/problems/0337.打家劫舍III.md
@@ -218,7 +218,72 @@ public:
 
 
 Java：
+```Java
+class Solution {
+    // 1.递归去偷，超时
+    public int rob(TreeNode root) {
+        if (root == null)
+            return 0;
+        int money = root.val;
+        if (root.left != null) {
+            money += rob(root.left.left) + rob(root.left.right);
+        }
+        if (root.right != null) {
+            money += rob(root.right.left) + rob(root.right.right);
+        }
+        return Math.max(money, rob(root.left) + rob(root.right));
+    }
 
+    // 2.递归去偷，记录状态
+    // 执行用时：3 ms , 在所有 Java 提交中击败了 56.24% 的用户
+    public int rob1(TreeNode root) {
+        Map<TreeNode, Integer> memo = new HashMap<>();
+        return robAction(root, memo);
+    }
+
+    int robAction(TreeNode root, Map<TreeNode, Integer> memo) {
+        if (root == null)
+            return 0;
+        if (memo.containsKey(root))
+            return memo.get(root);
+        int money = root.val;
+        if (root.left != null) {
+            money += robAction(root.left.left, memo) + robAction(root.left.right, memo);
+        }
+        if (root.right != null) {
+            money += robAction(root.right.left, memo) + robAction(root.right.right, memo);
+        }
+        int res = Math.max(money, robAction(root.left, memo) + robAction(root.right, memo));
+        memo.put(root, res);
+        return res;
+    }
+
+    // 3.状态标记递归
+    // 执行用时：0 ms , 在所有 Java 提交中击败了 100% 的用户
+    // 不偷：Max(左孩子不偷，左孩子偷) + Max(又孩子不偷，右孩子偷)
+    // root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) +
+    // Math.max(rob(root.right)[0], rob(root.right)[1])
+    // 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷
+    // root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;
+    public int rob3(TreeNode root) {
+        int[] res = robAction1(root);
+        return Math.max(res[0], res[1]);
+    }
+
+    int[] robAction1(TreeNode root) {
+        int res[] = new int[2];
+        if (root == null)
+            return res;
+
+        int[] left = robAction1(root.left);
+        int[] right = robAction1(root.right);
+
+        res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
+        res[1] = root.val + left[0] + right[0];
+        return res;
+    }
+}
+```
 
 Python：
 
diff --git a/problems/0491.递增子序列.md b/problems/0491.递增子序列.md
index 5e36d6be..ebcd9541 100644
--- a/problems/0491.递增子序列.md
+++ b/problems/0491.递增子序列.md
@@ -233,6 +233,34 @@ Python：
 
 Go：
 
+Javascript:
+
+```Javascript
+
+var findSubsequences = function(nums) {
+    let result = []
+    let path = []
+    function backtracing(startIndex) {
+        if(path.length > 1) {
+            result.push(path.slice())
+        }
+        let uset = []
+        for(let i = startIndex; i < nums.length; i++) {
+            if((path.length > 0 && nums[i] < path[path.length - 1]) || uset[nums[i] + 100]) {
+                continue
+            }
+            uset[nums[i] + 100] = true
+            path.push(nums[i])
+            backtracing(i + 1)
+            path.pop()
+        }
+    }
+    backtracing(0)
+    return result
+};
+
+```
+
 
 
 
diff --git a/problems/0509.斐波那契数.md b/problems/0509.斐波那契数.md
index 8537ed8b..8be11312 100644
--- a/problems/0509.斐波那契数.md
+++ b/problems/0509.斐波那契数.md
@@ -171,7 +171,20 @@ public:
 
 
 Java：
-
+```Java
+class Solution {
+    public int fib(int n) {
+        if (n < 2) return n;
+        int a = 0, b = 1, c = 0;
+        for (int i = 1; i < n; i++) {
+            c = a + b;
+            a = b;
+            b = c;
+        }
+        return c;
+    }
+}
+```
 
 Python：
 
diff --git a/problems/0647.回文子串.md b/problems/0647.回文子串.md
index fbc9133e..45bb72be 100644
--- a/problems/0647.回文子串.md
+++ b/problems/0647.回文子串.md
@@ -227,6 +227,30 @@ Python：
 
 
 Go：
+```Go
+func countSubstrings(s string) int {
+    res:=0
+    dp:=make([][]bool,len(s))
+    for i:=0;i<len(s);i++{
+        dp[i]=make([]bool,len(s))
+    }
+
+    for i:=len(s)-1;i>=0;i--{
+        for j:=i;j<len(s);j++{
+            if s[i]==s[j]{
+                if j-i<=1{
+                    res++
+                    dp[i][j]=true
+                }else if dp[i+1][j-1]{
+                    res++
+                    dp[i][j]=true
+                }
+            }
+        }
+    }
+    return res
+}
+```
 
 
 
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index 1653201e..89ed9176 100644
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/problems/1005.K次取反后最大化的数组和.md
@@ -124,7 +124,18 @@ class Solution {
 ```
 
 Python：
-
+```python
+class Solution:
+    def largestSumAfterKNegations(self, A: List[int], K: int) -> int:
+        A = sorted(A, key=abs, reverse=True) # 将A按绝对值从大到小排列
+        for i in range(len(A)):
+            if K > 0 and A[i] < 0:
+                A[i] *= -1
+                K -= 1
+        if K > 0:
+            A[len(A) - 1] *= ((-1)**K)
+        return sum(A)
+```
 
 Go：
 
@@ -135,4 +146,4 @@ Go：
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
 * 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
-<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
\ No newline at end of file
+<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 02d4b060..e8cf0bdd 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -115,7 +115,59 @@ void traversal(TreeNode* cur, vector<int>& vec) {
 
 
 Java：
+```Java
+// 前序遍历·递归·LC144_二叉树的前序遍历
+class Solution {
+    ArrayList<Integer> preOrderReverse(TreeNode root) {
+        ArrayList<Integer> result = new ArrayList<Integer>();
+        preOrder(root, result);
+        return result;
+    }
 
+    void preOrder(TreeNode root, ArrayList<Integer> result) {
+        if (root == null) {
+            return;
+        }
+        result.add(root.val);           // 注意这一句
+        preOrder(root.left, result);
+        preOrder(root.right, result);
+    }
+}
+// 中序遍历·递归·LC94_二叉树的中序遍历
+class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        inorder(root, res);
+        return res;
+    }
+
+    void inorder(TreeNode root, List<Integer> list) {
+        if (root == null) {
+            return;
+        }
+        inorder(root.left, list);
+        list.add(root.val);             // 注意这一句
+        inorder(root.right, list);
+    }
+}
+// 后序遍历·递归·LC145_二叉树的后序遍历
+class Solution {
+    public List<Integer> postorderTraversal(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        postorder(root, res);
+        return res;
+    }
+
+    void postorder(TreeNode root, List<Integer> list) {
+        if (root == null) {
+            return;
+        }
+        postorder(root.left, list);
+        postorder(root.right, list);
+        list.add(root.val);             // 注意这一句
+    }
+}
+```
 
 Python：