分割回文串--切割问题

题目描述

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

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

输入输出样例

示例 1：

输入：s = "ab"

输出：[["a","b"]

示例 2：

输入：s = "aab"

输出：[["a","a","b"],["aa","b"]]

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/palindrome-partitioning

算法描述

分割回文串有几个问题需要我们解决。

1. 如何分割字符串？

2. 如何判断回文串？

首先，第一个问题，分割字符串，相当于拿若干个隔板将字符串分割为若干个部分，而且这些子串都是回文串，所以问题的关键是隔板的位置如何确定？最直观暴力的方法就是，取到隔板所有的位置，然后再判断被隔板分割的子串是否全部都为回文串。很显然的一点是，如果我们要找到所有可能的分割位置，那一定需要迭代完整个字符串。

比如对于样例1，开始让第一个隔板的位置为0，第二个隔板的位置为1，那么分割的子串就是[0, 1)，也就是 ' a '，然后判断其是不是回文串，如果是，则说明这组隔板的位置可以，然后让第一个隔板的位置等于第二个隔板，然后让第二个隔板的位置等于第一个隔板的位置 + 1，也就是[1 , 2)，那么分割的子串就是 ' b '，然后判断，所以这组隔板的位置也可以，然后继续移动第一个隔板，也就是 2 ，即到了字符串的末尾，说明这一组分割方案是可以的，即 'a', 'b'。

然后继续迭代第二个隔板，那么分割的子串就是[0, 2)，就是 'ab'，发现子串不是回文串，说明该隔板的位置不可以，则继续后移该隔板，也就是[1, 3)，此时第二个隔板的位置到达字符串的末尾，说明这一组分割方案不行。

从上面的分析过程，可以很显然的看出，确定是否得到了一组分割方案就是看第一个隔板的最终位置，因为只有分割的子串为回文串时，第一个隔板才会移动，如果所有的隔板位置都是有效的，那么第一个隔板的位置一定会被移动到字符串的末尾。

而且可以发现，上述的过程跟回溯很像，一边横向迭代集合，一边移动隔板位置分割子串，一边记录分割方案。

实际上，其实切割问题类似于组合问题！我们每次确定好一个隔板的位置后，就会在剩下的子串中继续确定下一个隔板的位置。

所以我们可以按照回溯三部曲写出基本框架

vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
    for (int i = startIndex; i < s.size(); i++) {
       if (isPalindrome(s, startIndex, i)) {   // 是回文子串
           // 获取[startIndex,i]在s中的子串
           string str = s.substr(startIndex, i - startIndex + 1);
           path.push_back(str);
       } else {                                // 不是回文，跳过
            continue;
       }
       backtracking(s, i + 1); // 寻找i+1为起始位置的子串
       path.pop_back(); // 回溯过程，弹出本次已经填在的子串
    }
}

然后，第二个问题就是如何判断回文串，这个就比较简单了，可以使用双指针的方法，也可以使用rervese()函数来判断。

    bool isPalindrome(const string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s[i] != s[j]) {
                return false;
            }
        }
        return true;
    }

不难写出完整的代码。

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path; // 放已经回文的子串
    void backtracking (const string& s, int startIndex) {
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {   // 是回文子串
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            } else {                                // 不是回文，跳过
                continue;
            }
            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经填在的子串
        }
    }
    bool isPalindrome(const string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s[i] != s[j]) {
                return false;
            }
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

算法优化

上面的代码还存在一定的优化空间, 在于如何更高效的计算一个子字符串是否是回文字串。

上述代码isPalindrome函数运用双指针的方法来判定对于一个字符串s, 给定起始下标和终止下标, 截取出的子字符串是否是回文字串。但是其中有一定的重复计算存在:

例如给定字符串"abcde", 在已知"bcd"不是回文字串时, 不再需要去双指针操作"abcde"而可以直接判定它一定不是回文字串。

具体来说, 给定一个字符串s, 长度为n, 它成为回文字串的充分必要条件是s[0] == s[n-1]且s[1:n-1]是回文字串。

我们如果熟悉动态规划这种算法的话, 就可以高效地事先一次性计算出, 针对一个字符串s, 它的任何子串是否是回文字串, 然后在我们的回溯函数中直接查询即可, 省去了判定这一步骤。

优化后的具体代码。