diff --git a/problems/0005.最长回文子串.md b/problems/0005.最长回文子串.md
index 0f4cb2f6..de20feeb 100644
--- a/problems/0005.最长回文子串.md
+++ b/problems/0005.最长回文子串.md
@@ -270,6 +270,23 @@ public:
 ## Python
 
 ```python
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        dp = [[False] * len(s) for _ in range(len(s))]
+        maxlenth = 0
+        left = 0
+        right = 0
+        for i in range(len(s) - 1, -1, -1):
+            for j in range(i, len(s)):
+                if s[j] == s[i]:
+                    if j - i <= 1 or dp[i + 1][j - 1]:
+                        dp[i][j] = True
+                if dp[i][j] and j - i + 1 > maxlenth:
+                    maxlenth = j - i + 1
+                    left = i
+                    right = j
+        return s[left:right + 1]
+
 ```
 
 ## Go
diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index 3a31b918..3219d16f 100644
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@@ -216,6 +216,29 @@ var minSubArrayLen = function(target, nums) {
 };
 ```
 
+Swift:
+
+```swift
+func minSubArrayLen(_ target: Int, _ nums: [Int]) -> Int {
+    var result = Int.max
+    var sum = 0
+    var starIndex = 0
+    for endIndex in 0..<nums.count {
+        sum += nums[endIndex]
+
+        while sum >= target {
+            result = min(result, endIndex - starIndex + 1)
+            sum -= nums[starIndex]
+            starIndex += 1
+        }
+    }
+
+    return result == Int.max ? 0 : result
+}
+```
+
+
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)
diff --git a/problems/0279.完全平方数.md b/problems/0279.完全平方数.md
index 199259ac..e51f0a99 100644
--- a/problems/0279.完全平方数.md
+++ b/problems/0279.完全平方数.md
@@ -286,7 +286,35 @@ func min(a, b int) int {
 }
 ```
 
+Javascript:
+```Javascript
+// 先遍历物品，再遍历背包
+var numSquares1 = function(n) {
+    let dp = new Array(n + 1).fill(Infinity)
+    dp[0] = 0
 
+    for(let i = 0; i <= n; i++) {
+        let val = i * i
+        for(let j = val; j <= n; j++) {
+            dp[j] = Math.min(dp[j], dp[j - val] + 1)
+        }
+    }
+    return dp[n]
+};
+// 先遍历背包，再遍历物品
+var numSquares2 = function(n) {
+    let dp = new Array(n + 1).fill(Infinity)
+    dp[0] = 0
+
+    for(let i = 1; i <= n; i++) {
+        for(let j = 1; j * j <= i; j++) {
+            dp[i] = Math.min(dp[i - j * j] + 1, dp[i])
+        }
+    }
+
+    return dp[n]
+};
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
diff --git a/problems/0496.下一个更大元素I.md b/problems/0496.下一个更大元素I.md
index bbc21d24..589ee8ad 100644
--- a/problems/0496.下一个更大元素I.md
+++ b/problems/0496.下一个更大元素I.md
@@ -186,7 +186,37 @@ public:
 建议大家把情况一二三想清楚了，先写出版本一的代码，然后在其基础上在做精简！
 
 ## 其他语言版本
+Java
+```java
+class Solution {
+    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+        Stack<Integer> temp = new Stack<>();
+        int[] res = new int[nums1.length];
+        Arrays.fill(res,-1);
+        HashMap<Integer, Integer> hashMap = new HashMap<>();
+        for (int i = 0 ; i< nums1.length ; i++){
+            hashMap.put(nums1[i],i);
+        }
+        temp.add(0);
+        for (int i = 1; i < nums2.length; i++) {
+            if (nums2[i] <= nums2[temp.peek()]) {
+                temp.add(i);
+            } else {
+                while (!temp.isEmpty() && nums2[temp.peek()] < nums2[i]) {
+                    if (hashMap.containsKey(nums2[temp.peek()])){
+                        Integer index = hashMap.get(nums2[temp.peek()]);
+                        res[index] = nums2[i];
+                    }
+                    temp.pop();
+                }
+                temp.add(i);
+            }
+        }
 
+        return res;
+    }
+}
+```
 Python：
 ```python3
 class Solution:
diff --git a/problems/0503.下一个更大元素II.md b/problems/0503.下一个更大元素II.md
index 13c2cb29..9f38d80d 100644
--- a/problems/0503.下一个更大元素II.md
+++ b/problems/0503.下一个更大元素II.md
@@ -95,7 +95,6 @@ public:
 ## 其他语言版本
 
 Java: 
-
 ```Java 
 class Solution {
     public int[] nextGreaterElements(int[] nums) {
diff --git a/problems/0669.修剪二叉搜索树.md b/problems/0669.修剪二叉搜索树.md
index 3b315350..267497b4 100644
--- a/problems/0669.修剪二叉搜索树.md
+++ b/problems/0669.修剪二叉搜索树.md
@@ -296,6 +296,7 @@ Go：
  *     Right *TreeNode
  * }
  */
+// 递归
 func trimBST(root *TreeNode, low int, high int) *TreeNode {
     if root==nil{
         return nil
@@ -312,6 +313,37 @@ func trimBST(root *TreeNode, low int, high int) *TreeNode {
     root.Right=trimBST(root.Right,low,high)
     return root
 }
+// 迭代
+func trimBST(root *TreeNode, low int, high int) *TreeNode {
+    if root == nil {
+        return nil
+    }
+    // 处理 root，让 root 移动到[low, high] 范围内，注意是左闭右闭
+    for root != nil && (root.Val<low||root.Val>high){
+        if root.Val < low{
+            root = root.Right
+        }else{
+            root = root.Left
+        }
+    }
+    cur := root
+    // 此时 root 已经在[low, high] 范围内，处理左孩子元素小于 low 的情况（左节点是一定小于 root.Val，因此天然小于 high）
+    for cur != nil{
+        for cur.Left!=nil && cur.Left.Val < low{
+            cur.Left = cur.Left.Right
+        }
+        cur = cur.Left
+    }
+    cur = root
+    // 此时 root 已经在[low, high] 范围内，处理右孩子大于 high 的情况
+    for cur != nil{
+        for cur.Right!=nil && cur.Right.Val > high{
+            cur.Right = cur.Right.Left
+        }
+        cur = cur.Right
+    }
+    return root
+}
 ```
 
 
diff --git a/problems/哈希表总结.md b/problems/哈希表总结.md
index 49da3c6f..28865920 100644
--- a/problems/哈希表总结.md
+++ b/problems/哈希表总结.md
@@ -84,7 +84,7 @@ std::set和std::multiset底层实现都是红黑树，std::unordered_set的底
 来说一说：使用数组和set来做哈希法的局限。
 
 * 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
-* set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下表位置，因为要返回x 和 y的下表。所以set 也不能用。
+* set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。
 
 map是一种`<key, value>`的结构，本题可以用key保存数值，用value在保存数值所在的下表。所以使用map最为合适。