update 0131.分割回文串: 修改错字，替换 go 代码

problems/0131.分割回文串.md

@@ -43,8 +43,8 @@
 
 例如对于字符串abcdef：
 
-* 组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中在选组第三个.....。
+* 组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个.....。
-* 切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中在切割第三段.....。
+* 切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段.....。
 
 感受出来了不？
 
@@ -78,7 +78,7 @@ void backtracking (const string& s, int startIndex) {
 
 ![131.分割回文串](https://code-thinking.cdn.bcebos.com/pics/131.%E5%88%86%E5%89%B2%E5%9B%9E%E6%96%87%E4%B8%B2.jpg)
 
-从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止终止条件。
+从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。
 
 **那么在代码里什么是切割线呢？**
 
@@ -98,7 +98,7 @@ void backtracking (const string& s, int startIndex) {
 
 * 单层搜索的逻辑
 
-**来看看在递归循环，中如何截取子串呢？**
+**来看看在递归循环中如何截取子串呢？**
 
 在`for (int i = startIndex; i < s.size(); i++)`循环中，我们 定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。
 
@@ -126,7 +126,7 @@ for (int i = startIndex; i < s.size(); i++) {
 
 最后我们看一下回文子串要如何判断了，判断一个字符串是否是回文。
 
-可以使用双指针法，一个指针从前向后，一个指针从后先前，如果前后指针所指向的元素是相等的，就是回文字符串了。
+可以使用双指针法，一个指针从前向后，一个指针从后向前，如果前后指针所指向的元素是相等的，就是回文字符串了。
 
 那么判断回文的C++代码如下：
 
@@ -295,7 +295,7 @@ public:
 
 除了这些难点，**本题还有细节，例如：切割过的地方不能重复切割所以递归函数需要传入i + 1**。
 
-所以本题应该是一个道hard题目了。
+所以本题应该是一道hard题目了。
 
 **可能刷过这道题目的录友都没感受到自己原来克服了这么多难点，就把这道题目AC了**，这应该叫做无招胜有招，人码合一，哈哈哈。
 
@@ -432,45 +432,39 @@ class Solution:
 ```
 
 ## Go 
-**注意切片（go切片是披着值类型外衣的引用类型）**
 ```go
+var (
+    path []string  // 放已经回文的子串
+    res  [][]string
+)
 func partition(s string) [][]string {
-    var tmpString []string//切割字符串集合
+    path, res = make([]string, 0), make([][]string, 0)
-    var res [][]string//结果集合
+    dfs(s, 0)
-    backTracking(s,tmpString,0,&res)
     return res
 }
-func backTracking(s string,tmpString []string,startIndex int,res *[][]string){
+
-    if startIndex==len(s){//到达字符串末尾了
+func dfs(s string, start int) {
-        //进行一次切片拷贝，怕之后的操作影响tmpString切片内的值
+    if start == len(s) { // 如果起始位置等于s的大小，说明已经找到了一组分割方案了
-        t := make([]string, len(tmpString))
+        tmp := make([]string, len(path))
-		copy(t, tmpString)
+        copy(tmp, path)
-        *res=append(*res,t)
+        res = append(res, tmp)
+        return 
     }
-    for i:=startIndex;i<len(s);i++{
+    for i := start; i < len(s); i++ {
-        //处理（首先通过startIndex和i判断切割的区间，进而判断该区间的字符串是否为回文，若为回文，则加入到tmpString，否则继续后移，找到回文区间）（这里为一层处理）
+        str := s[start : i+1]
-        if isPartition(s,startIndex,i){
+        if isPalindrome(str) {   // 是回文子串
-            tmpString=append(tmpString,s[startIndex:i+1])
+            path = append(path, str)
-        }else{
+            dfs(s, i+1)         // 寻找i+1为起始位置的子串
-            continue
+            path = path[:len(path)-1]  // 回溯过程，弹出本次已经填在的子串
         }
-        //递归
-        backTracking(s,tmpString,i+1,res)
-        //回溯
-        tmpString=tmpString[:len(tmpString)-1]
     }
 }
-//判断是否为回文
+
-func isPartition(s string,startIndex,end int)bool{
+func isPalindrome(s string) bool {
-    left:=startIndex
+    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
-    right:=end
+        if s[i] != s[j] {
-    for ;left<right;{
-        if s[left]!=s[right]{
             return false
         }
-        //移动左右指针
-        left++
-        right--
     }
     return true
 }