Leetcode 131&132. Palindrome Partitioning I & II

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

题目解析

本题要求求取所有可能的回文子串排列模式。我采取的想法是找出该字符串中所有是回文字符串的子串，然后类似生成一张图，使用深度优先搜索得到结果。我将子串的结果保存在一个map >中，map[i]代表i位置为起点的，能够构成回文字符串的长度为j。

代码

代码如下：

class Solution {
public:
// 判断是否是回文子串
    bool valid(string s)
    {
        string s1 = s;
        reverse(s1.begin(), s1.end());
        if (s1 == s)
            return true;
        return false;
    }

// 深度优先搜索构建
    void solve(map<int, vector<int>> &mii, int idx, vector<vector<string>> &vvs, string s,vector<string> &vs)
    {
        if (idx == s.size())
        {
            vvs.push_back(vs);
            return;
        }
        else
        {
            vector<int> v = mii[idx];
            for (int i = 0; i < v.size(); ++i)
            {
                vs.push_back(s.substr(idx, v[i]));
                solve(mii, idx + v[i], vvs, s, vs);
                vs.pop_back();
            }
        }
    }

// 生成回文子串
    vector<vector<string>> partition(string s) {
        vector<vector<string>> vvs;
        map<int, vector<int> > mii;
        vector<string> vs;        
        int length = 1;
        for (; length <= s.size(); ++length)
        {
            for (int i = 0; i < s.size(); ++i)
            {
                if (i + length <= s.size())
                {
                    if (valid(s.substr(i, length)))
                    {
                        mii[i].push_back(length);
                    }
                }
                else
                {
                    break;
                }
            }
        }   
        solve(mii, 0, vvs, s, vs);
        /*for (int i = 0; i < vvs.size(); ++i)
        {
        for (int j = 0; j < vvs[i].size(); ++j)
        cout << vvs[i][j] << " ";
        cout << endl;
        }*/
        return vvs;
    }
};

132. Palindrome Partitioning II

题目

Given a string s, partition s such that every substring of the partition is a palindrome.
Return the minimum cuts needed for a palindrome partitioning of s.
For example, given s = "aab",
Return 1 since the palindrome partitioning ["aa","b"]could be produced using1cut.

题目解析

本题要求给出一个最短的分割结果。
当然最直接的想法是利用上一题得到的结果，获得所有可能的划分里的最小值，但这样直观感觉肯定会超时，不然也对不起这题是hard难度哈哈。

想法一

想到利用类似动态规划的思路：f[n] = min(f[i]+1)，其中s[i,n]之间构成回文字符串。两层循环加判断是否是回文字符串，然而最后一个测试用例超时，一个长达1400个字符的大哥==。
代码如下：

bool valid(string s)
{
    string s1 = s;
    reverse(s1.begin(), s1.end());
    if (s1 == s)
        return true;
    return false;
}

int minCut(string s) {
    if(s.size()<=1)
        return 0;
    vector<int> fn(s.size()+1, -1);
    for (int i = 1; i <= s.size(); ++i)
    {
        int minDis = INT_MAX;
        for (int j = 0; j < i; ++j)
        {           
            if (valid(s.substr(j,i-j)))
            {
                minDis = min(fn[j] + 1, minDis);
            }
        }
        fn[i] = minDis;
    }
    return fn[s.size()];
}

想法二

想着为啥想法一会超时，应该是对于同一个字符串重复计算，因此使用备忘录字符串，记录是回文字符串和不是回文字符串的子串，但还是超时。后来仔细一看，这个备忘录方法并没有起到作用，因为在我这样的写法中，每个只会计算一次，备忘录方法并没有作用。备忘录还是用的不溜啊==
代码如下：

class Solution {
public:
        map<int, set<int>> mii; // 回文串
        map<int, set<int>> miix;// 不是回文串
    bool valid(string s, int i, int j)
    {
        if (mii[i].count(j))
            return true;
        if (miix[i].count(j))
            return false;
        string s1 = s.substr(i, j);
        string s2 = s1;
        reverse(s1.begin(), s1.end());
        if (s1 == s2)
        {
            mii[i].insert(j);
            return true;
        }
        else
        {
            miix[i].insert(j);
            return false;
        }

    }
    int minCut(string s) {
        if (s.size() <= 1)
            return 0;
        vector<int> fn(s.size() + 1, -1);
        for (int i = 1; i <= s.size(); ++i)
        {
            int minDis = INT_MAX;
            for (int j = 0; j < i; ++j)
            {
                if (valid(s, j, i - j))
                {
                    minDis = min(fn[j] + 1, minDis);                
                }
            }
            fn[i] = minDis;
        }
        return fn[s.size()];
    }
};

想法三

思来想去，前面的方法的动态规划思想是对的，但时间应该是荒废在了判断回文字符串上，由于偷懒，这样的写法对于测试用例里1000多长度的字符串兄弟非常费时。思来想去如何减缓时间，网上看到大神的解法，顿然领悟，链接，终于AC了，好开森。
重点来了：对于判断一个字符串是否是回文串，判定[i,j]是字符串需要满足以下条件s[i]==s[j] && vvi[i+1][j-1]=true，当然也有[i,j]长度小于等于1的情况。
代码如下：

class Solution {
public:
    int minCut(string s) {
        if (s.size() <= 1)
            return 0;
        vector<int> fn(s.size()+1, 0);
        vector<vector<bool>> vvi(s.size(), vector<bool>(s.size(), false));
        for (int i = s.size()-1; i >=0; --i)
        {
            int minDis = INT_MAX;
            for (int j = i; jif ((s[i] == s[j]) && ((j - i <= 1) || vvi[i + 1][j - 1]))
                {
                    vvi[i][j] = true;
                    minDis = min(fn[j+1] + 1, minDis);  
                }            
            }       
            fn[i] = minDis;
        }
        return fn[0]-1;
    }
};

欢迎指正。