LeetCode刷题——分割回文串#131#Medium

分割回文串的思路探讨与源码
    分割回文串的题目如下图，该题属于字符串和回溯类型的题目，主要考察对于回溯方法的使用和字符串搜索遍历方法的理解。本文的题目作者想到2种方法，分别是回溯搜索方法和记忆化递归方法，其中回溯搜索方法使用Java进行编写，而记忆化递归方法使用Python进行编写，当然这可能不是最优的解法，还希望各位大佬给出更快的算法。

    本人认为该题目可以使用回溯搜索方法进行解决，首先初始化动态规划处理的参数和储存结果的数组，然后开始处理字符串，首先计算字符串长度，然后将字符串的长度作为动态规划数组初始化的大小进行初始化，然后遍历赋值，对动态规划数组每个元素都赋值为true，赋值完毕后开始对二维数组进行遍历，判断二维数组的横纵下标对应的字符串的值是否相等并且右上方的动态规划数组的元素值是否为true，如果都是true就给当前的元素赋值为true，否则就赋值为false，然后遍历完毕后调用回溯搜索函数，在函数的内部先判断当前下标是否和字符串的长度相等，如果相等就把列表结果加入到最终结果里并结束搜索，否则就开始遍历动态规划数组，如果数组值为true就把字符串的对应范围元素加入到结果列表里，然后继续迭代搜索下一个，然后再把结果列表的最后一个元素移除，最终等到搜索结束就返回最终结果。那么按照这个思路我们的Java代码如下：

#喷火龙与水箭龟
class Solution {
    boolean[][] arr;
    int num = -1;
    List<String> resFinal = new ArrayList<String>();
    List<List<String>> partFinal = new ArrayList<List<String>>();
   
    public List<List<String>> partition(String s) {
        num = s.length();
        arr = new boolean[num][num];
        for (int ir = 0; ir < num; ir++) {
            Arrays.fill(arr[ir],true);
        }
        for (int ib = num - 1; ib >= 0; ib--) {
            for (int jb = ib + 1; jb < num; jb++) {
                arr[ib][jb] = (s.charAt(ib) == s.charAt(jb)) && arr[ib + 1][jb - 1];
            }
        }
        searchDFS(s,0);
        return partFinal;
    }

    public void searchDFS(String s, int ir) {
        if (ir==num) {
            partFinal.add(new ArrayList<String>(resFinal));
            return;
        }
        for (int jr = ir; jr < num; jr++) {
            if (arr[ir][jr]) {
                resFinal.add(s.substring(ir,jr+1));
                searchDFS(s,jr+1);
                int endNum = resFinal.size() - 1;
                resFinal.remove(endNum);
            }
        }
    }
}

    显然，我们看到回溯搜索的方法的效果不错，同时还可以使用记忆化递归的方法。首先判断字符串是否为空，如果是就直接返回空的结果。然后判断字符串的长度，如果长度是1就直接返回字符串的列表结果。开始先初始化一个结果列表，然后循环分割遍历字符串，如果分割的前段是回文串，就去用前段的值去加后段的每个值，最终返回搜索的结果列表。所以按照这个思路就可以解决，下面是Python代码部分：

#喷火龙与水箭龟
class Solution:
    @lru_cache(None)
    def partition(self, s: str) -> List[List[str]]:
        if(not s):
            return [[]]
        sLen = len(s)
        if(sLen == 1):
            return [[s]]
        resFinal = []
        for jr in range(1,sLen+1):
            if s[:jr][::-1] == s[:jr]:
                resFinal = resFinal + [[s[:jr]] + kb  for kb in self.partition(s[jr:])]
        return resFinal

    从结果来说Java版本的回溯搜索方法的效率比较不错，而Python版本的记忆化递归方法的速度一般，但应该是有更多的方法可以进一步提速的，希望朋友们能够多多指教，非常感谢。