diff --git a/problems/0037.解数独.md b/problems/0037.解数独.md
index fc1e3114..aaac4c7c 100644
--- a/problems/0037.解数独.md
+++ b/problems/0037.解数独.md
@@ -42,9 +42,9 @@
 
 **如果以上这几道题目没有做过的话，不建议上来就做这道题哈！**
 
-[N皇后问题](https://programmercarl.com/0051.N皇后.html)是因为每一行每一列只放一个皇后，只需要一层for循环遍历一行，递归来来遍历列，然后一行一列确定皇后的唯一位置。
+[N皇后问题](https://programmercarl.com/0051.N皇后.html)是因为每一行每一列只放一个皇后，只需要一层for循环遍历一行，递归来遍历列，然后一行一列确定皇后的唯一位置。
 
-本题就不一样了，**本题中棋盘的每一个位置都要放一个数字（而N换后是一行只放一个皇后），并检查数字是否合法，解数独的树形结构要比N皇后更宽更深**。
+本题就不一样了，**本题中棋盘的每一个位置都要放一个数字（而N皇后是一行只放一个皇后），并检查数字是否合法，解数独的树形结构要比N皇后更宽更深**。
 
 因为这个树形结构太大了，我抽取一部分，如图所示：
 
@@ -75,7 +75,7 @@ bool backtracking(vector<vector<char>>& board)
 
 **那么有没有永远填不满的情况呢？**
 
-这个问题我在递归单层搜索逻辑里在来讲！
+这个问题我在递归单层搜索逻辑里再来讲！
 
 * 递归单层搜索逻辑
 
@@ -207,7 +207,7 @@ public:
 
 所以我在开篇就提到了**二维递归**，这也是我自创词汇，希望可以帮助大家理解解数独的搜索过程。
 
-一波分析之后，在看代码会发现其实也不难，唯一难点就是理解**二维递归**的思维逻辑。
+一波分析之后，再看代码会发现其实也不难，唯一难点就是理解**二维递归**的思维逻辑。
 
 **这样，解数独这么难的问题，也被我们攻克了**。
 
@@ -331,55 +331,56 @@ class Solution:
 ### Go 
 
 ```go
-func solveSudoku(board [][]byte)  {
-    var backtracking func(board [][]byte) bool
-    backtracking=func(board [][]byte) bool{
-        for i:=0;i<9;i++{
-            for j:=0;j<9;j++{
-                //判断此位置是否适合填数字
-                if board[i][j]!='.'{
-                    continue
-                }
-                //尝试填1-9
-                for k:='1';k<='9';k++{
-                    if isvalid(i,j,byte(k),board)==true{//如果满足要求就填
-                        board[i][j]=byte(k)
-                       if  backtracking(board)==true{
-                           return true
-                       }
-                        board[i][j]='.'
-                    }
-                }
-                return false
-            }
-        }
-        return true
-    }
-    backtracking(board)
+func solveSudoku(board [][]byte) {
+	var backtracking func(board [][]byte) bool
+	backtracking = func(board [][]byte) bool {
+		for i := 0; i < 9; i++ {
+			for j := 0; j < 9; j++ {
+				//判断此位置是否适合填数字
+				if board[i][j] != '.' {
+					continue
+				}
+				//尝试填1-9
+				for k := '1'; k <= '9'; k++ {
+					if isvalid(i, j, byte(k), board) == true { //如果满足要求就填
+						board[i][j] = byte(k)
+						if backtracking(board) == true {
+							return true
+						}
+						board[i][j] = '.'
+					}
+				}
+				return false
+			}
+		}
+		return true
+	}
+	backtracking(board)
 }
+
 //判断填入数字是否满足要求
-func isvalid(row,col int,k byte,board [][]byte)bool{
-    for i:=0;i<9;i++{//行
-        if board[row][i]==k{
-            return false
-        }
-    }
-    for i:=0;i<9;i++{//列
-        if board[i][col]==k{
-            return false
-        }
-    }
-    //方格
-    startrow:=(row/3)*3
-    startcol:=(col/3)*3
-    for i:=startrow;i<startrow+3;i++{
-        for j:=startcol;j<startcol+3;j++{
-            if board[i][j]==k{
-                return false
-            }
-        }
-    }
-    return true
+func isvalid(row, col int, k byte, board [][]byte) bool {
+	for i := 0; i < 9; i++ { //行
+		if board[row][i] == k {
+			return false
+		}
+	}
+	for i := 0; i < 9; i++ { //列
+		if board[i][col] == k {
+			return false
+		}
+	}
+	//方格
+	startrow := (row / 3) * 3
+	startcol := (col / 3) * 3
+	for i := startrow; i < startrow+3; i++ {
+		for j := startcol; j < startcol+3; j++ {
+			if board[i][j] == k {
+				return false
+			}
+		}
+	}
+	return true
 }
 ```