leetcode解题笔记-Palindrome Partitioning

练习算法，反思总结

Palindrome Partitioning

题目地址：https://oj.leetcode.com/problems/palindrome-partitioning/

题目大致意思是将一个字符串分成若干子串，要求每个子串都是回文字符串

刚看到题目，想到肯定要利用递归，我刚开始想到的是使用动态规划，我的思路（超时了，但是还是总结一下）是这样的：

利用一个数组arr[i][j]表示从字符串中的第i个字符到第j个字符中的分割方法,比如对于“aab”这个字符串arr[0][1]=[['a','a'],['aa']]。这样从长度1开始，一直处理到字符串的长度，但是这种方案超时了，对于一个n长度的字符串，大致需要(1+...+n)次的计算。该方案代码如下：

<pre name="code" class="html">class Solution:
    # @param s, a string
    # @return a list of lists of string
    def partition(self, s):
        length = len(s)
        if length == 0:
            return []
        arr = [[[] for i in range(0,length)] for j in range(0,length)]
        count = 0
        for i in range(1,len(s)+1):
            for j in range(0,len(s)-i+1):
                count+=1
                if i==1:
                    arr[j][j].append([s[j:j+1]])
                else:
                    if s[j:j+i] == s[j:j+i][::-1]:
                        arr[j][j+i-1].append([s[j:j+i]])
                    for l in range(1,i):
                        left = s[j:j+l]
                        right = arr[j+l][j+i-1]
                        if left!=left[::-1] or len(right)==0:
                            continue
                        for n in range(0,len(right)):
                            arr[j][j+i-1].append([left]+right[n])
                            print count
        return arr[0][len(s)-1]

在上述代码的实现过程中遇到个小问题。本来我是这样处理arr[i][j]的，l->1-(j-1),然后将arr[i][l]和arr[l+1][j]合并，这会造成重复。所以修改成s[i:i+l]和arr[l+1][j]合并。

正如我前面说的，计算次数太多了。

现在leetcode推出了提示功能，提示为traceback，回溯法。想想确实能减少次数，因为在处理过程中会剪枝。代码如下：

class Solution:
    # @param s, a string
    # @return a list of lists of string
    def partition(self, s):
        self.result = []
        self.backtrace(s,[])
        return self.result
    def backtrace(self,s,arr):
        if len(s)==0:
            self.result.append(arr[::])
        for i in range(0,len(s)):
            strs = s[0:i+1:]
            if strs == strs[::-1]:
                arr.append(strs)
                self.backtrace(s[i+1::],arr)
                arr.pop()

回溯法。回溯时会用一个列表来保存程序经过的路径。当这个路径需要回溯时，就把列表中的最后一项给删掉。