Leetcode: Palindrome Partitioning II

參考：http://www.cppblog.com/wicbnu/archive/2013/03/18/198565.html

我太喜歡用dfs和回溯法了，但是這些暴力的方法加上剪枝之後複雜度依然是很高，顯然不能達到題目的要求。

這個時候應該考慮動態規劃，並且要複雜度儘量接近O(n^2)的演算法。

下面這個方法更加簡潔：自長到短找到迴文串後，往後dfs，並記錄遞迴深度表示並更新最小劃分數。http://fisherlei.blogspot.com/2013/03/leetcode-palindrome-partitioning-ii.html

---

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 using 1 cut.

題解：
類似矩陣連乘的動歸思路。
dp[i][j]=min(dp[i][k]+dp[k+1][j]+1), i<=k<j.
但是用這個方程的時間是O(n^3)，簡化dp[i][j]為dp[i]，表示從0到i的minCut.
dp[i]=min(dp[k]+1,       dp[k]+i-k), 0<=k<i.

 (s[k+1, i]是迴文串）   (s[k+1, i]不是迴文串)

具體程式碼參見上述連結。

值得注意的是，計算是否為迴文數的過程中也要用記憶化搜尋才能減少重複比較的次數，it's smart~

 MY CODE：

//
//  ParlindromePartitioningII.cpp
//  SJMcode
//
//  Created by Jiamei Shuai on 13-8-31.
//  Copyright (c) 2013年 Jiamei Shuai. All rights reserved.
//

#include <vector>
#include <iostream>
#include <string.h>
#include <assert.h>
using namespace std;

// 兩處優化：
// 1.已經計算過的區間的最短劃分次數用map紀錄
// 2.迴文串的判斷結果也要用map記錄

class Solution{
public:
    int *minCutMat;
    vector<vector<int> > map;
    
    int IsPalindrome(string &s, int i, int j)
    {
        if(i>j) return false;
        if(map[i][j]!= -1)
            return map[i][j];
        if(i==j)
            return map[i][j]=1;
        
        if(s[i]!=s[j])
            return map[i][j]=0;
        else{
            if(j-i==1)
                return map[i][j]=1;
            else
                return map[i][j]=IsPalindrome(s,i+1,j-1);
        }
    }
    
    
    int minCut(string s) // 動態規劃  d[i] = min{d[k]+1, d[k]+i-k}, 0<=k<i
    {
        int n = (int)s.length();
        if(n==0||n==1)
            return 0;
        
        vector<int> min, vtmp;
        min.clear();vtmp.clear();map.clear();
        for(int i=0; i<s.size(); i++)
        {
            min.push_back(0);
            vtmp.push_back(-1);
        }
        for(int i=0; i<s.size(); i++)
            map.push_back(vtmp);

        int tmp, ans;
        for(int inter = 1; inter<n; inter++)
        {
            if(IsPalindrome(s, 0, inter))
                min[inter]=0;
            else{
                ans = n+1;
                for(int k = 0; k < inter; k++)
                {
                    if(IsPalindrome(s, k+1, inter))
                        tmp = min[k]+1;
                    else
                        tmp = min[k] + inter - k;
                    if(tmp < ans)
                        ans = tmp;
                }
                min[inter] = ans;
            }
        }
        return min[n-1];
    }
    
    
    
    // 較複雜的演算法用dfs或者回溯法都太慢了，加上了所有的剪枝策略還是會超時
    // 這種情況大多數都應該使用動態規劃，要多總結，少犯錯誤。
    
    int minCut2(string s) // 總是超時，複雜度太高
    //這個方法相當於類似矩陣鏈乘的演算法，dp[i][j] = min(dp[i][k]+dp[k+1][j]), i<=k<j,複雜度是O(n^3)
    //可以簡化dp[i][j]為dp[i]，表示從0到i的minCut
    {
        int minCutNum = (int)s.size();
        int len = (int)s.size();
        
        minCutMat = new int[len*len]; // 注意new int[]而不是()
        memset(minCutMat, -1, len*len*sizeof(int));
        
        vector<int> vtmp;
        vtmp.clear();map.clear();
        for(int i=0; i<s.size(); i++)
            vtmp.push_back(-1);
        for(int i=0; i<s.size(); i++)
            map.push_back(vtmp);
        
        // Notice: if the string need no split and itself a palindrome, how to handle it? 注意細節
        if(IsPalindrome(s, 0, len-1)) return 0;
                
        split(s, 0, len-1, minCutNum);
        
        delete []minCutMat;
        
        return minCutNum;
    }
    
    int split(string &s, int begin, int end, int &minCutNum)
    {
        if(begin == end) return 0;
        
        if(IsPalindrome(s, begin, end)) return 0;
        
        int minCurrentSplit = (int)s.size();
        int left,right;
        
        for(int i = begin; i < end; i++)
        {
            assert(begin*s.size()+i < s.size()*s.size());
            assert(begin*s.size()+i < s.size()*s.size());
            if(minCutMat[begin*s.size()+i] >= 0)
                left = minCutMat[begin*s.size()+i];
            else
            {
                left = split(s, begin, i, minCutNum);
                minCutMat[begin*s.size()+i] = left;
            }
            if(left >= minCutNum) { return 1<<20;}
            
            if(minCutMat[(i+1)*s.size()+end] >= 0)
                right = minCutMat[(i+1)*s.size()+end];
            else
            {
                right = split(s, i+1, end, minCutNum);
                minCutMat[(i+1)*s.size()+end] = right;
            }
            if(right >= minCutNum) return 1<<20;
            
            int tmp = left + 1 + right;
            
            minCurrentSplit = min(tmp, minCurrentSplit);
            
            if(begin == 0 && end == s.size()-1) // outer loop
                minCutNum = min(tmp, minCutNum);
        }
        return minCurrentSplit;
    }

};

int main()
{
    Solution sln;
    cout << sln.minCut("apjesgpsxoeiokmqmfgvjslcjukbqxpsobyhjpbgdfruqdkeiszrlmtwgfxyfostpqczidfljwfbbrflkgdvtytbgqalguewnhvvmcgxboycffopmtmhtfizxkmeftcucxpobxmelmjtuzigsxnncxpaibgpuijwhankxbplpyejxmrrjgeoevqozwdtgospohznkoyzocjlracchjqnggbfeebmuvbicbvmpuleywrpzwsihivnrwtxcukwplgtobhgxukwrdlszfaiqxwjvrgxnsveedxseeyeykarqnjrtlaliyudpacctzizcftjlunlgnfwcqqxcqikocqffsjyurzwysfjmswvhbrmshjuzsgpwyubtfbnwajuvrfhlccvfwhxfqthkcwhatktymgxostjlztwdxritygbrbibdgkezvzajizxasjnrcjwzdfvdnwwqeyumkamhzoqhnqjfzwzbixclcxqrtniznemxeahfozp");
    
    return 0;
}

 

 附上更簡潔的演算法：

1：        int minCut(string s) {  
2:            int len = s.size();  
3:            int D[len+1];  
4:            bool P[len][len];  
5:            //the worst case is cutting by each char  
6:            for(int i = 0; i <= len; i++)   
7:            D[i] = len-i;  
8:            for(int i = 0; i < len; i++)  
9:            for(int j = 0; j < len; j++)  
10:            P[i][j] = false;  
11:            for(int i = len-1; i >= 0; i--){  
12:                 for(int j = i; j < len; j++){  
13:                      if(s[i] == s[j] && (j-i<2 || P[i+1][j-1])){  
14:                           P[i][j] = true;  
15:                           D[i] = min(D[i],D[j+1]+1);  
16:                      }  
17:                 }  
18:            }  
19:            return D[0]-1;  
20:       }  

 

以及使用回溯+剪枝的方法：

1:    int minCut(string s) {  
2:      int min = INT_MAX;  
3:      DFS(s, 0, 0, min);  
4:      return min;  
5:    }  
6:    void DFS(string &s, int start, int depth, int& min)  
7:    {     
8:      if(start == s.size())  
9:      {  
10:        if(min> depth-1)  
11:          min = depth-1;  
12:        return;  
13:      }  
14:      for(int i = s.size()-1; i>=start; i--)  //find the biggest palindrome first
15:      {  
16:        if(isPalindrome(s, start, i))  
17:        {        
18:          DFS(s, i+1, depth+1, min);  
19:        }  
20:       
21:       
22:      }  
23:    }  
24:    bool isPalindrome(string &s, int start, int end)  
25:    {  
26:      while(start< end)  
27:      {  
28:        if(s[start] != s[end])  
29:          return false;  
30:        start++; end--;  
31:      }  
32:      return true;  
33:    }  

 

 

總結下來，要學會分析問題，不能一成不變的只用一個演算法，可能會非常低效。