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<int,set<int> >中，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; j<s.size(); ++j)
            {
                if ((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;
    }
};

歡迎指正。