131. 分割回文串

最新推荐文章于 2024-11-03 19:16:06 发布

百里守约学编程

最新推荐文章于 2024-11-03 19:16:06 发布

阅读量1.2k

点赞数 18

分类专栏： # 回溯算法文章标签： golang leetcode 算法

本文链接：https://blog.csdn.net/YouMing_Li/article/details/142682347

版权

回溯算法专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章目录

131. 分割回文串
思路
回溯三部曲
判断回文子串
总结

131. 分割回文串

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

示例 1：

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

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

思路

本题这涉及到两个关键问题：

切割问题，有不同的切割方式
判断回文

相信这里不同的切割方式可以搞懵很多同学了。

这种题目，想用for循环暴力解法，可能都不那么容易写出来，所以要换一种暴力的方式，就是回溯。

一些同学可能想不清楚回溯究竟是如何切割字符串呢？

我们来分析一下切割，其实切割问题类似组合问题。

例如对于字符串abcdef：

组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个…，回溯到第一层后，横向for循环选取ab，然后从cdef中继续递归选取…。
切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段…，回溯到第一层后，横向for循环切割得到ab，然后从cdef中继续递归切割…。

注：实际上没有剪枝的情况下，每一层都是先把该层横向情况都遍历完后，才回溯到上一层，这里为了方便，直接举例回溯到第一层后又开始如何处理的（看下面的图更好理解）

感受出来了不？

所以切割问题，也可以抽象为一棵树形结构，如图：

在这里插入图片描述

这里多一嘴，大家跟着这个序号走一遍，是不是发现遍历方式和N叉树的前序遍历几乎一模一样，即每一层都是先拿到根节点（中），然后遍历该节点的所有子节点，子节点又有子节点，直到遍历到没有子节点的那一层后，往上回归一层，继续遍历上一层递归中同层中的下一个子节点。

for循环用来横向遍历，递归用来纵向遍历，切割线（就是图中的红线）切割到字符串的结尾位置，说明找到了一个切割方法。

此时可以发现，切割问题的回溯搜索的过程和组合问题的回溯搜索的过程是差不多的。

回溯三部曲

1.递归函数参数
二维切片res存放结果集，一维切片path存放切割后回文的子串，本题递归函数参数也需要startIndex，因为切割过的地方，不能重复切割，和组合问题也是保持一致的。

在回溯算法：39. 组合总和中我们深入探讨了组合问题什么时候需要startIndex，什么时候不需要startIndex。

如果是一个集合来求组合的话，就需要startIndex，例如：77. 组合以及216.组合总和III

如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合

注意: 以上只是说求组合的情况，如果是排列问题，又是另一套分析的套路，后面在讲解排列的时候会重点介绍。

代码如下：

func backtracking(s string,res *[][]string,path *[]string,startIndex int){}

2.递归函数终止条件
在这里插入图片描述
从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。

那么在代码里什么是切割线呢？

在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。

所以终止条件代码如下：

// 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
if startIndex >= len(s) {
    *res = append(*res ,append([]string(nil),*path...))
    return
}

3.单层搜索的逻辑
来看看在递归循环中如何截取子串呢？

在for i := startIndex;i < len(s);i++循环中，我们定义了起始位置startIndex，那么 s[startIndex:i+1]就是要截取的子串，注意是i+1,因为是左闭右开的。

首先判断这个子串是不是回文，如果不是则直接跳过，不需要继续往下切割了，可以直接在同层i后移一位作为新的切割点，如果是回文，就加入到path中，path用来记录切割过的回文子串。

代码如下：

for i := startIndex;i < len(s);i++ {
    str := s[startIndex:i+1] // 获取[startIndex,i]在s中的子串
    if !Palindrome(str) { // 如果不是回文串则直接跳过
        continue
    }
    *path = append(*path,str)
    backtracking(s,res,path,i + 1) // 寻找i+1为起始位置的子串
    *path = (*path)[0:len(*path) - 1]  // 回溯过程，弹出本次已经添加的子串
}

注意切割过的位置，不能重复切割，所以，backtracking(s,res,path,i + 1), 传入下一层的起始位置为i + 1。

判断回文子串

最后我们看一下回文子串要如何判断了，判断一个字符串是否是回文。

可以使用双指针法，一个指针从前向后，一个指针从后向前，如果前后指针所指向的元素是相等的，就是回文字符串了。

那么判断回文的Go代码如下：

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

此时关键代码已经讲解完毕，整体代码如下（详细注释了）

根据回溯算法模板：

func backtracking(参数) {
    if 终止条件) {
        存放结果
        return
    }

    for 选择：本层集合中元素（树中节点孩子的数量就是集合的大小） {
        处理节点
        backtracking(路径，选择列表) // 递归
        回溯，撤销处理结果
    }
}

不难写出如下Go代码：

func partition(s string) [][]string {
    if len(s) == 0 {
        return nil
    }
    res := make([][]string,0)
    path := make([]string,0)
    backtracking(s,&res,&path,0)
    return res
}

func backtracking(s string,res *[][]string,path *[]string,startIndex int){
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if startIndex >= len(s) {
        *res = append(*res ,append([]string(nil),*path...))
        return
    }
    for i := startIndex;i < len(s);i++ {
        str := s[startIndex:i+1] // 获取[startIndex,i]在s中的子串
        if !Palindrome(str) { // 如果不是回文串则直接跳过
            continue
        }
        *path = append(*path,str)
        backtracking(s,res,path,i + 1) // 寻找i+1为起始位置的子串
        *path = (*path)[0:len(*path) - 1]  // 回溯过程，弹出本次已经添加的子串
    }
}

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