【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;

    }

};