leetcode 131 分割回文串

题目

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]

解析

下面的讲解每次看起来总觉得很长，要记的东西太多了，来记一种以答案为导向的方法：

func partition(s string) [][]string {
	var res [][]string
	var path []string
	n := len(s)
	var dfs func(i int)
	dfs = func(i int) {
		if i == n {
			temp := make([]string, len(path))
			copy(temp, path)
			res = append(res, temp)
			return
		}
		for j := i; j < n; j++ {
			t := s[i : j+1] // 切片的截法，比如aab，要截取a，就是s[0,1]
			if isHuiWen(t) {
				path = append(path, t)
				dfs(j + 1)
				path = path[:len(path)-1]
			}
		}
	}
	dfs(0)
	return res
}

func isHuiWen(t string) bool {
	left := 0
	right := len(t) - 1
	for left < right {
		if t[left] != t[right] {
			return false
		}
		left++
		right--
	}
	return true
}

---

这道题和之前的回溯算法，从定义上稍微有些区别，之前的算下来都是组合问题，这个是属于分割问题；
对于分割问题，也可以在脑海里构想出一棵树来，for循环用来横向遍历，递归用来纵向遍历；终止条件就是要切割的下标到了字符串的末尾；
首先用回溯三部曲来分析一下：
1.确定递归参数：
根据经验，这个其实不用太早确定，可以写递归函数的时候，遇到什么觉得需要传，再传进去就是。对于本次，可能需要的参数是：题目的入参s，还有标志位index，还有一维数组path，和二维数组res的地址，目前就想到这几个；
2.确定终止条件：
这道题的终止条件就是标志位到了整个给定字符串的最后，然后本题中由于需要在后面的逻辑中判断是回文才会追加到path中，所以不必在终止条件这里考虑别的，只看标志位到了就行
3.单层递归逻辑：
在单层递归中进行逻辑处理的时候，判断要截取的符合条件的字串的时候，先循环截取[index,i]这个区间，然后判断s的下标在这个区间的是不是满足回文，不满足的话就continue，再次循环；满足的话，将这个区间追加到path中，再递归，再回溯

func partition(s string) [][]string {
    var path []string
    var res [][]string
    backtracking(s, 0, path, &res)
    return res
}

func backtracking(s string, startIndex int, path []string, res *[][]string) {
	// 终止条件可以这样判断，不能用len(path)==len(s)的方法，[["aa","b"]]的就会被漏掉
    if startIndex == len(s) { //注意这里是s
        tmp := make([]string, len(path))
        copy(tmp, path)
        *res = append(*res, tmp)
        return 
    }
    for i := startIndex; i < len(s); i++ {
        if !isPartiton(s, startIndex, i) {
            continue
        }
        path = append(path, s[startIndex : i+1]) //以startIndex分割，之后的若是回文串，就append；这里的+1是截取切片的用法，比如“aab”要截取第一个a，那么就是s[0:1]
        backtracking(s, i+1, path, res) // 切割过的位置，不能再切割，所有要+1
        path = path[:len(path)-1] //一个一个的回溯
    }
}

func isPartiton(s string, start, end int) bool {
    for start < end {
        if s[start] != s[end] {
            return false
        }
        start++
        end--
    }
    return true
}