【leetcode】 Palindrome Partitioniong (middle) (*^__^*)

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

Return all possible palindrome partitioning of s.

For example, given s = "aab",
Return

  [
    ["aa","b"],
    ["a","a","b"]
  ]

思路：

回溯，但是不是常规回溯，因为解向量大小不定，需要动态判断。 下面是我写的代码， 只用了19ms 非常快， 自己挺满意的。

感受：之前做过DP求最少切几刀令所有部分都是回文，跟这个有点像。 觉得凡是求最的都是用DP，凡是求所有解的都是用回溯。

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> ans;
        if(s.empty())
            return ans;

        vector<vector<bool>> isPalindrome(s.length(), vector<bool>(s.length(), false));
        vector<vector<int>> S(s.length(), vector<int>(2, 0)); //每个深度候选范围 用下标范围来记录
        int k = 0;
        vector<string> X;

        while(k >= 0)
        {
            while(k >= 0 && S[k][1] < s.length()) //当前深度判断完毕 通过当前范围结束下标到达s的最后
            {
                int i = S[k][0]; //当前深度判断位置的起始下标
                int j = S[k][1]; //当前深度判断位置的结束下标
                if(s[i] == s[j] && (j - i < 2 || isPalindrome[i+1][j - 1])) //分次判断是否为回文，每次使用历史信息
                {
                    isPalindrome[i][j] = true;
                    while(X.size() >= k + 1) //X长度不固定，所以用的时候会有上一次求解的值，我们需要把多出的部分弹出 ！！特别注意
                    {
                        X.pop_back();
                    }
                    X.push_back(s.substr(i, j - i + 1));
                    S[k][1]++;
                    if(S[k][1] < s.length())
                    {
                        k++;
                        S[k][0] = S[k - 1][1];
                        S[k][1] = S[k - 1][1];
                    }
                    else
                    {
                        ans.push_back(X);
                    }
                }
                else
                {
                    S[k][1]++;
                }
            }
            k--;
        }
        return ans;
    }
};