leetcode【131】Palindrome Partitioning【c++版，时间99%，空间100%】

问题描述：

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

Example:

Input: "aab"
Output:
[
  ["aa","b"],
  ["a","a","b"]
]

源码：

首先来看看递归大法（最近好像全是这种搜索问题），有个小技巧，就是把substr用在if之后，这样可以避免很多次substr，节省了空间和时间。最终时间99%，空间100%。

class Solution {
private:
    string str;
    vector<vector<string>> result;
    vector<string> path;
    bool isPalindrome(int left, int right) {
        while(left < right){
            if(str[left] != str[right])     return false;
            else{
                left++;     right--;
            }
        }
        return true;
    }
    
    void dfs(int start){
        int n = str.length();
        if(start == n){
            result.push_back(path);
            return;
        }
        for(int i=start; i<n; i++){
            if(!isPalindrome(start, i))     continue;
            path.push_back(str.substr(start, i-start+1));
            dfs(i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        int n = s.length();
        if(n==0)    return result;
        str = s;
        dfs(0);
        return result;
    }
};

在网上看到一种动态规划的方法，效率不是很高，仅供参考：

这里还是像上个解法一样建立判断字符串s的子串是否为回文串的dp数组，但建立了一个三维数组的res，这里的res数组其实也可以看作是一个dp数组，其中 res[i] 表示前i个字符组成的子串，即范围 [0, i+1] 内的子串的所有拆分方法，那么最终只要返回 res[n] 极为所求。然后进行for循环，i 从 0 到 n，j 从 0 到 i，这里我们同时更新了两个dp数组，一个是回文串的dp数组，另一个就是结果res数组了，对于区间 [j, i] 的子串，若其是回文串，则 dp[j][i] 更新为 true，并且遍历 res[j] 中的每一种组合，将当前子串加入，并且存入到 res[i+1] 中，参见代码如下：

class Solution {
public:
    vector<vector<string>> partition(string s) {
        int n = s.size();
        vector<vector<vector<string>>> res(n + 1);
        res[0].push_back({});
        vector<vector<bool>> dp(n, vector<bool>(n));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j <= i; ++j) {
                if (s[i] == s[j] && (i - j <= 2 || dp[j + 1][i - 1])) {
                    dp[j][i] = true;
                    string cur = s.substr(j, i - j + 1);
                    for (auto list : res[j]) {
                        list.push_back(cur);
                        res[i + 1].push_back(list);
                    }
                }
            }
        }
        return res[n];
    }
};