Leetcode 131：分割回文串（最详细的解法！！！）

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: "aab"
输出:
[
  ["aa","b"],
  ["a","a","b"]
]

解题思路

这个问题和前面的 Leetcode 93：复原IP地址（最详细的解法！！！）很类似。首先想到的解法是回溯法。

我们首先判断a是不是回文字符，我们发现是，所以将a加入到list中，接着我们看后面的a，依次下去，当我们第一次遍历完整个字符串的时候，result中就加入了['a','a','b']。接着我们再次遍历，我们发现aa是回文字符串，我们将aa加入到list中，然后我们判断b是一个回文字符，我们将b加入到list中，现在result中就包含了['aa', 'b']。接着我们第三次遍历，我们发现aab不是一个字符串，然而输入的字符大小就是3，这个时候我们输出result。

class Solution:
    def _partition(self, s, index, t, result):
        if index == len(s):
            result.append(t.copy())
            return 

        for i in range(index+1, len(s)+1):
            if s[index:i] == s[index:i][::-1]:
                t.append(s[index:i])
                self._partition(s, i, t, result)
                t.pop()
        
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        result = list()
        if not s:
            return result
        
        self._partition(s, 0, list(), result)
        return result

同样的，对于递归可以解决的问题，我们都应该思考是不是可以通过迭代解决。我们看一下该怎么做，我们首先遍历s中的字符，对于每个字符，我们首先将他加入到一个临时的list中。

当我们遍历到第一个a的时候，我们首先将其加入到list中。

当我们遍历到第二个a的时候，我们首先将其加入到list中，接着我们发现'aa'构成回文串，所以我们同时需要将'aa'也加入进来（此时我们放到新的一排）。

当我们遍历到b的时候，我们首先将其加入到list中，接着我们就要判断他和之前的元素a是否可以构成回文或者和之前的两个元素['a','a']是否可以构成回文（注意是第一排，不是第二排），我们发现都不行。

class Solution:
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        results = [[]]
        
        for c in s:
            for r in results:
                r.append(c)
                
            tmp = []
            for r in results:
                if len(r) > 1:
                    p = ''.join(r[-2:])
                    if p == p[::-1]:
                        tmp.append(r[:-2] + [p])
                    elif len(r) > 2:
                        p = ''.join(r[-3:])
                        if p == p[::-1]:
                            tmp.append(r[:-3] + [p])
                            
            results.extend(tmp)
        return results

上面的代码中有过多的分支语句，我们希望可以优化一下代码。所以很自然的写出下面的代码

if len(r) > 1:
    p = ''.join(r[-2:])
    if p == p[::-1]:
        tmp.append(r[:-2] + [p])
elif len(r) > 2:
    p = ''.join(r[-3:])
    if p == p[::-1]:
        tmp.append(r[:-3] + [p])

但是这个代码是错的，考虑这样的例子efe。当我们考虑到第三个e的时候，此时我们的list是[['e','f']]，我们会首先将a加入到其中就变成了[['e','f','e']]，接着我们发现'e'和'f'不可以构成回文，所以我们不可以构成回文，我们的判断就结束了。那能不能这样写？

if len(r) > 1:
    p = ''.join(r[-2:])
    if p == p[::-1]:
        tmp.append(r[:-2] + [p])
if len(r) > 2: # dif
    p = ''.join(r[-3:])
    if p == p[::-1]:
        tmp.append(r[:-3] + [p])

也是错误的，考虑这样的例子aaa。当我们考虑到第三个a的时候，此时我们的list是[['a','a'],['aa']]，我们会首先将a加入到其中就变成了[['a','a','a'],['aa','a']]。接着我们考虑第一行，我们发现'a'和'a'可以构成回文，所以我们加入['a', 'aa']，我们发现a，a和a可以构成回文，所以加入['aaa']。接着我们考虑第二行，我们发现a和aa可以构成回文，所以我们加入['aaa']。此时我们发现加入了重复的一项。

一个稍微好一点的解决方案如下

class Solution:
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        if not s: 
            return []

        res = [[]]
        for i, x in enumerate(s):
            tmp = []
            for r in res:
                tmp.append(r+[x])
                if len(r) >= 1 and r[-1] == x: 
                    tmp.append(r[:-1]+[r[-1]+x])
                    
                if len(r) >= 2 and r[-2] == x: 
                    tmp.append(r[:-2]+[r[-2]+r[-1]+x])
                    
            res = tmp
        return res

但是算法思路和前者稍有不同，不过也只是大同小异罢了。

我将该问题的其他语言版本添加到了我的GitHub Leetcode

如有问题，希望大家指出！！！