Update

Author: applewjg

PalindromePartitioning.h

@@ -1,6 +1,7 @@
 /*
- Author:     Annie Kim, [email protected]
+ Author:     Annie Kim, [email protected] : King, [email protected]
  Date:       May 20, 2013
+ Update:     Oct 06, 2014
  Problem:    Palindrome Partitioning
  Difficulty: Easy
  Source:     http://leetcode.com/onlinejudge#question_131
@@ -19,36 +20,60 @@
 
 class Solution {
 public:
-    vector<vector<string>> res;
     vector<vector<string>> partition(string s) {
-        res.clear();
-        vector<string> part;
-        partitionRe(s, 0, part);
-        return res;
+        return partition_2(s);
     }
-
-    void partitionRe(const string &s, int start, vector<string> &part) {
-        if (start == s.size())
-        {
-            res.push_back(part);
-            return;
+    vector<vector<string>> partition_2(string s) {
+        int size = s.size();
+        vector<vector<bool> > dp(size, vector<bool>(size));
+        for (int i = size - 1; i >= 0; --i) {
+            for (int j = i; j < size; ++j) {
+                dp[i][j]=(s[i]==s[j])&&(j<i+2||dp[i+1][j-1]);
+            }
         }
-        string palindrom;
-        for (int i = start; i < s.size(); ++i) {
-            palindrom.push_back(s[i]);
-            if (!isPalindrome(palindrom)) continue;
-            part.push_back(palindrom);
-            partitionRe(s, i + 1, part);
-            part.pop_back();
+        vector<vector<string> > res[size];
+        for (int i = size - 1; i >= 0; --i) {
+            for (int j = i; j < size; ++j) {
+                if (dp[i][j] == false) continue;
+                string word = s.substr(i, j - i + 1);
+                if (j == size - 1) {
+                    res[i].push_back(vector<string>{word});
+                } else {
+                    for (auto iter : res[j+1]) {
+                        iter.insert(iter.begin(), word);
+                        res[i].push_back(iter);
+                    }
+                }
+            }
         }
+        return res[0];
     }
 
-    bool isPalindrome(const string &s) {
-        int i = 0, j = s.size()-1;
-        while (i < j) {
-            if (s[i] != s[j]) return false;
-            i++; j--;
+    vector<vector<string>> partition_1(string s) {
+        int size = s.size();
+        vector<vector<bool> > dp(size, vector<bool>(size));
+        for (int i = size - 1; i >= 0; --i) {
+            for (int j = i; j < size; ++j) {
+                dp[i][j]=(s[i]==s[j])&&(j<i+2||dp[i+1][j-1]);
+            }
+        }
+        vector<vector<string> > res;
+        vector<string> path;
+        dfs(s, dp, 0, path, res);
+        return res;
+    }
+    void dfs(string s, vector<vector<bool> > &dp, int start, vector<string> &path, vector<vector<string> > &res) {
+        int size = s.size();
+        if (start == size) {
+            res.push_back(path);
+        }
+        for (int i = start; i < size; ++i) {
+            if (dp[start][i] == false) {
+                continue;
+            }
+            path.push_back(s.substr(start, i - start + 1));
+            dfs(s, dp, i + 1, path, res);
+            path.pop_back();
         }
-        return true;
     }
 };

PalindromePartitioningII.h

@@ -17,22 +17,20 @@
 class Solution {
 public:
     int minCut(string s) {
-        int N = s.size();
-        bool isP[N];
-        int dp[N];
-        dp[0] = 0;
-        for (int i = 1; i < N; ++i) 
-        {
-            isP[i] = true;
-            dp[i] = dp[i-1] + 1;
-            for (int j = 0; j < i; ++j) 
-            {
-                isP[j] = (s[i] == s[j]) ? isP[j+1] : false; // isP[j] == true   -> [j...i] is a palindrome
-                                                            // isP[j+1] == true -> [j+1...i-1] is a palindrome
-                if (isP[j])
-                    dp[i] = (j == 0) ? 0 : min(dp[i], dp[j-1] + 1);  // dp[i] -> minCount for [0...i]
+        int size = s.size();
+        vector<int> dp(size + 1);
+        vector<bool> isP(size, true);
+        dp[size] = -1;
+        for (int i = size -1; i >= 0; --i) {
+            dp[i] = dp[i + 1] + 1;
+            for (int j = size - 1; j >= i; --j) {
+                isP[j] = false;
+                if (s[i] == s[j] && ( j - i < 2 || isP[j-1])) {
+                    isP[j] = true;
+                    dp[i] = min(dp[i], dp[j + 1] + 1);
+                }
             }
         }
-        return dp[N-1];
+        return dp[0];
     }
-};
+};