【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>(, )); //每个深度候选范围 用下标范围来记录
        int k = ;
        vector<string> X;

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