diff --git a/problems/0200.岛屿数量.深搜版.md b/problems/0200.岛屿数量.深搜版.md
index 18442943..83d295bd 100644
--- a/problems/0200.岛屿数量.深搜版.md
+++ b/problems/0200.岛屿数量.深搜版.md
@@ -37,7 +37,7 @@
 
 在遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。
 
-那么如果把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。 
+那么如何把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。 
 
 ### 深度优先搜索 
 
diff --git a/problems/0647.回文子串.md b/problems/0647.回文子串.md
index d94d18c5..4887ff83 100644
--- a/problems/0647.回文子串.md
+++ b/problems/0647.回文子串.md
@@ -397,6 +397,7 @@ class Solution:
 ```
 
 ### Go：
+> 动态规划：
 
 ```Go
 func countSubstrings(s string) int {
@@ -422,6 +423,47 @@ func countSubstrings(s string) int {
     return res
 }
 ```
+> 动态规划：简洁版
+```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] && (j-i <= 1 || dp[i+1][j-1]) {
+				res++
+				dp[i][j] = true
+			}
+		}
+	}
+	return res
+}
+```
+
+> 双指针法：
+```Go
+func countSubstrings(s string) int {
+	extend := func(i, j int) int {
+		res := 0
+		for i >= 0 && j < len(s) && s[i] == s[j] {
+			i --
+			j ++
+			res ++
+		}
+		return res
+	}
+	res := 0
+	for i := 0; i < len(s); i++ {
+		res += extend(i, i)  // 以i为中心
+		res += extend(i, i+1) // 以i和i+1为中心
+	}
+	return res
+}
+```
 
 ### Javascript：
 
diff --git a/problems/0827.最大人工岛.md b/problems/0827.最大人工岛.md
index 3f32dd7a..7930c7a1 100644
--- a/problems/0827.最大人工岛.md
+++ b/problems/0827.最大人工岛.md
@@ -348,6 +348,99 @@ class Solution:
 
 ```
 
+
+### Go
+
+```go
+func largestIsland(grid [][]int) int {
+	dir := [][]int{{0, 1}, {1, 0}, {-1, 0}, {0, -1}}
+	n := len(grid)
+	m := len(grid[0])
+	area := 0
+	visited := make([][]bool, n)
+	for i := 0; i < n; i++ {
+		visited[i] = make([]bool, m)
+	}
+	gridNum := make(map[int]int, 0) // 记录每一个岛屿的面积
+	mark := 2                       // 记录每个岛屿的编号
+	isAllGrid := true
+	res := 0 // 标记是否整个地图都是陆地
+
+	var dfs func(grid [][]int, visited [][]bool, x, y, mark int)
+	dfs = func(grid [][]int, visited [][]bool, x, y, mark int) {
+		// 终止条件：访问过的节点 或者 遇到海水
+		if visited[x][y] || grid[x][y] == 0 {
+			return
+		}
+		visited[x][y] = true // 标记访问过
+		grid[x][y] = mark    // 给陆地标记新标签
+		area++
+		for i := 0; i < 4; i++ {
+			nextX := x + dir[i][0]
+			nextY := y + dir[i][1]
+			if nextX < 0 || nextX >= len(grid) || nextY < 0 || nextY >= len(grid[0]) {
+				continue
+			}
+			dfs(grid, visited, nextX, nextY, mark)
+		}
+	}
+
+	for i := 0; i < n; i++ {
+		for j := 0; j < m; j++ {
+			if grid[i][j] == 0 {
+				isAllGrid = false
+			}
+			if !visited[i][j] && grid[i][j] == 1 {
+				area = 0
+				dfs(grid, visited, i, j, mark) // 将与其链接的陆地都标记上 true
+				gridNum[mark] = area           // 记录每一个岛屿的面积
+				mark++                         // 更新下一个岛屿编号
+			}
+		}
+	}
+	if isAllGrid {
+		return n * m
+	}
+	// 根据添加陆地的位置，计算周边岛屿面积之和
+	visitedGrid := make(map[int]struct{}) // 标记访问过的岛屿
+	for i := 0; i < n; i++ {
+		for j := 0; j < m; j++ {
+			count := 1                           // 记录连接之后的岛屿数量
+			visitedGrid = make(map[int]struct{}) // 每次使用时，清空
+			if grid[i][j] == 0 {
+				for k := 0; k < 4; k++ {
+					// 计算相邻坐标
+					nearI := i + dir[k][0]
+					nearJ := j + dir[k][1]
+					if nearI < 0 || nearI >= len(grid) || nearJ < 0 || nearJ >= len(grid[0]) {
+						continue
+					}
+					// 添加过的岛屿不要重复添加
+					if _, ok := visitedGrid[grid[nearI][nearJ]]; ok {
+						continue
+					}
+					// 把相邻四面的岛屿数量加起来
+					count += gridNum[grid[nearI][nearJ]]
+					// 标记该岛屿已经添加过
+					visitedGrid[grid[nearI][nearJ]] = struct{}{}
+				}
+			}
+			res = max827(res, count)
+		}
+	}
+	return res
+}
+
+func max827(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
+
+```
+
+
 ### JavaScript
 
 ```JavaScript
@@ -411,8 +504,6 @@ return res;
 ```
 
 
-
-
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index edd55aad..4621d4a7 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -180,26 +180,34 @@ class Solution {
 
 class Solution:
     def preorderTraversal(self, root: TreeNode) -> List[int]:
-        if not root:
-            return []
-
-        left = self.preorderTraversal(root.left)
-        right = self.preorderTraversal(root.right)
-
-        return  [root.val] + left +  right
+        res = []
+        
+        def dfs(node):
+            if node is None:
+                return
+            
+            res.append(node.val)
+            dfs(node.left)
+            dfs(node.right)
+        
+        return res
 
 ```
 ```python
 # 中序遍历-递归-LC94_二叉树的中序遍历
 class Solution:
     def inorderTraversal(self, root: TreeNode) -> List[int]:
-        if root is None:
-            return []
-
-        left = self.inorderTraversal(root.left)
-        right = self.inorderTraversal(root.right)
-
-        return left + [root.val] + right
+        res = []
+        
+        def dfs(node):
+            if node is None:
+                return
+            
+            dfs(node.left)
+            res.append(node.val)
+            dfs(node.right)
+        
+        return res
 ```
 ```python
 
@@ -207,13 +215,17 @@ class Solution:
 # 后序遍历-递归-LC145_二叉树的后序遍历
 class Solution:
     def postorderTraversal(self, root: TreeNode) -> List[int]:
-        if not root:
-            return []
-
-        left = self.postorderTraversal(root.left)
-        right = self.postorderTraversal(root.right)
-
-        return left + right + [root.val]
+        res = []
+        
+        def dfs(node):
+            if node is None:
+                return
+            
+            dfs(node.left)
+            dfs(node.right)
+            res.append(node.val)
+        
+        return res
 ```
 
 ### Go：