leetcode-Palindrome Partitioning

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"]
  ]

题目是要求出一个字符串的所有回文字串的划分。

这道题可以用递归搜索解决，从头扫描字符串扫描过的是子串是回文串时，把这个回文子串添加队列尾，然后就从下一个位置再递归递归找回文字串划分，

返回时要把当前回文字串从队列尾删去，再继续扫描。

class Solution {
public:
    vector<vector<string>> partition(string s) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        ret.clear();
        vector<string> part;
        findPalindrome(s, 0, part);
        return ret;
    }
    
    void findPalindrome(const string &s, int k, vector<string>& part) {   //从位置k出发找，part记录回文串集合
        if (k == s.size()) {
            ret.push_back(part);  //找到一个划分，放入结果集合
            return;
        }
        string temp;
        for (int i=k; i<s.size(); ++i) {
            temp = s.substr(k, i-k+1);
            if (isPalindrome(temp)) {
                part.push_back(temp);
                findPalindrome(s, i+1, part);
                part.pop_back();
            }
        }
    }
private:
    vector<vector<string> > ret;
    
    bool isPalindrome(const string& s) {
        int i= 0;
        int j = s.size()-1;
        while (i<j) {
            if (s[i] != s[j])
                return false;
            ++i;
            --j;
        }
        return true;
    }
};

搜索过程中也可以记录已经搜索过的字符串，这样可以避免重复求解子问题。

class Solution {
public:
    vector<vector<string> > partition(string s) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        memory.clear();
        return findPalindrome(s, 0);
    }
    
    /* 找出位置k出发的回文串划分集合 */
    vector<vector<string>> findPalindrome(const string &s, int k) {
        vector<vector<string>> ret, vvs;
        vector<string> vs;
        string tempS;
        
        for (int i=k; i<s.size(); ++i) {
            tempS = s.substr(k, i-k+1);
            
            if (isPalindrome(s, k, i)) {    //k到i是回文串
                if ((i+1) == s.size()) {
                    vs.clear();
                    vs.push_back(tempS);
                    ret.push_back(vs);
                    break;
                }
                
                if (memory.find(i+1) != memory.end())   
                    vvs = memory[i+1];
                else  
                    vvs = findPalindrome(s, i+1);     // 找出i+1后的回文串
                
                for (int j=0; j<vvs.size(); ++j) {   //组合回文串
                    vs.clear();
                    vs.push_back(tempS);
					insert_iterator<vector<string>> it(vs, vs.begin()+1);
                    copy(vvs[j].begin(), vvs[j].end(), it);
					ret.push_back(vs);
                }
            }
        }
        
        memory[k] = ret;
        return ret;
    }
private:
    map<int, vector<vector<string>>> memory;  //存储原字符串下标i对应的回文串划分集合
    
    bool isPalindrome(const string& s, int b, int e) {
        while (b<e) {
            if (s[b] != s[e])
                return false;
            ++b;
            --e;
        }
        return true;
    }
};

但是耗时反而比不用记忆化搜索多，可能是因为比较多的拷贝工作。