leetcode -- 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 using 1 cut.[解题思路]记录所有合法的回文分割，最后得到最小的回文分割数，Large data TLE

public class Solution {
public int minCut(String s) {
// Start typing your Java solution below
// DO NOT write main() function
ArrayList<ArrayList<String>> result = partition(s);
int minCut = Integer.MAX_VALUE;
for(int i = 0; i < result.size(); i++){
if(result.get(i).size() < minCut){
minCut = result.get(i).size();
}
}
return minCut - 1;
}

public ArrayList<ArrayList<String>> partition(String s) {
// Start typing your Java solution below
// DO NOT write main() function
ArrayList<ArrayList<String>> result = new ArrayList<ArrayList<String>>();
ArrayList<String> output = new ArrayList<String>();
int depth = 0, len = s.length();

palinPartition(s, 0, len, output, result);
return result;
}

public void palinPartition(String s, int start, int len, ArrayList<String> output,
ArrayList<ArrayList<String>> result){
if(start == len){
ArrayList<String> tmp = new ArrayList<String>();
tmp.addAll(output);
result.add(tmp);
return;
}

for(int i = start; i < len; i++){
if(isPalindrome(s, start, i)){
output.add(s.substring(start, i + 1));
palinPartition(s, i + 1, len, output, result);
output.remove(output.size() - 1);
}
}

}

public boolean isPalindrome(String s, int start, int end){
while(start < end){
if(s.charAt(start) != s.charAt(end)){
return false;
}
start ++;
end --;
}

return true;
}
}

updated:using DPLet F(i) = min cut for s[i]…s[n-1] so F(0) is our answer and we have:F(i) = min(1 + F(j)) for j = i + 1, … n-1 and s[i]…s[j-1] is palidromic
F(i) = 0 if s[i]…s[n-1] is palindromic

public static int minCut(String s) {
// Start typing your Java solution below
// DO NOT write main() function
if (s == null) {
return 0;
}
int len = s.length();
int[] cuts = new int[len];
for (int i = len - 1; i >= 0; i--) {
String str = s.substring(i);
if (isPalindrome(str)) {
cuts[i] = 0;
} else {
cuts[i] = getMin(s, i, len, cuts);
}
}
return cuts[0];
}

public static int getMin(String s, int i, int len, int[] cuts) {
int min = Integer.MAX_VALUE;
for (int j = i + 1; j < len; j++) {
if (cuts[j] < min && isPalindrome(s.substring(i, j))) {
min = cuts[j];
}
}
return min + 1;
}

public static boolean isPalindrome(String s) {
int len = s.length();
int i = 0, j = len - 1;
while (i < j) {
if (s.charAt(i) != s.charAt(j)) {
return false;
}
i++;
j--;
}
return true;
}

"a"    0    0

"ab"    1    1

"bb"    0    0

"cdd"    1    1

"dde"    1    1

"efe"    0    0

"fff"    0    0

"abbab"    1    1

"leet"    2    2

"coder"    4    4

"abcccb"    1    1

"cabababcbc"    3    3

"cbbbcc"    1    1

"ccaacabacb"    3    3

"racecar"    0    0

"danaranad"    0    0

"ababbbabbaba"    3    3

"amanaplanacanalpanama"    0    0

"seeslaveidemonstrateyetartsnomedievalsees"    0    0

"eegiicgaeadbcfacfhifdbiehbgejcaeggcgbahfcajfhjjdgj"    42    42

"kwtbjmsjvbrwriqwxadwnufplszhqccayvdhhvscxjaqsrmrrqngmuvxnugdzjfxeihogzsdjtvdmkudckjoggltcuybddbjoizu"    89    89

"ltsqjodzeriqdtyewsrpfscozbyrpidadvsmlylqrviuqiynbscgmhulkvdzdicgdwvquigoepiwxjlydogpxdahyfhdnljshgjeprsvgctgnfgqtnfsqizonirdtcvblehcwbzedsmrxtjsipkyxk"    143    143

"ababababababababababababcbabababababababababababa"    0    0

"fifgbeajcacehiicccfecbfhhgfiiecdcjjffbghdidbhbdbfbfjccgbbdcjheccfbhafehieabbdfeigbiaggchaeghaijfbjhi"    75    75

"apjesgpsxoeiokmqmfgvjslcjukbqxpsobyhjpbgdfruqdkeiszrlmtwgfxyfostpqczidfljwfbbrflkgdvtytbgqalguewnhvvmcgxboycffopmtmhtfizxkmeftcucxpobxmelmjtuzigsxnncxpaibgpuijwhankxbplpyejxmrrjgeoevqozwdtgospohznkoyzocjlracchjqnggbfeebmuvbicbvmpuleywrpzwsihivnrwtxcukwplgtobhgxukwrdlszfaiqxwjvrgxnsveedxseeyeykarqnjrtlaliyudpacctzizcftjlunlgnfwcqqxcqikocqffsjyurzwysfjmswvhbrmshjuzsgpwyubtfbnwajuvrfhlccvfwhxfqthkcwhatktymgxostjlztwdxritygbrbibdgkezvzajizxasjnrcjwzdfvdnwwqeyumkamhzoqhnqjfzwzbixclcxqrtniznemxeahfozp"    452    452

"adabdcaebdcebdcacaaaadbbcadabcbeabaadcbcaaddebdbddcbdacdbbaedbdaaecabdceddccbdeeddccdaabbabbdedaaabcdadbdabeacbeadbaddcbaacdbabcccbaceedbcccedbeecbccaecadccbdbdccbcbaacccbddcccbaedbacdbcaccdcaadcbaebebcceabbdcdeaabdbabadeaaaaedbdbcebcbddebccacacddebecabccbbdcbecbaeedcdacdcbdbebbacddddaabaedabbaaabaddcdaadcccdeebcabacdadbaacdccbeceddeebbbdbaaaaabaeecccaebdeabddacbedededebdebabdbcbdcbadbeeceecdcdbbdcbdbeeebcdcabdeeacabdeaedebbcaacdadaecbccbededceceabdcabdeabbcdecdedadcaebaababeedcaacdbdacbccdbcece"    273    273

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"    1    1

large data
已范错误：line 23:if (cuts[j] < min && isPalindrome(s.substring(i, j - 1)))
这里应是s.substring(i, j)，表示i到j-1之间的字符串。
getMin函数的含义是：在i+1~n-2之间砍一刀，看之间的字符串是否是回文，如是则看看是否是最小值，如是则更新可以改进的地方：
判断是否是回文也可以用dp来解updated：2013/10/06上面的解法的时间复杂度为O(n^3)，值得优化的地方在判断字符串是否是回文，这个地方会有重复计算1.计算字符串的所有子串是否是回文，DP解　　i.长度为1的子串都是回文　　ii.长度为2的子串：s[i]==s[j]　　iii.长度为其他的子串：s[i]==s[j] && matrix[i+1][j-1]2.计算minCut，DP和上面相同

public static int minCut(String s) {
if (s == null || s.length() <= 1) {
return 0;
}

int len = s.length();
int[] dp = new int[len];
boolean[][] palindromeMatrix = new boolean[len][len];
for (int i = 0; i < len; i++) {
palindromeMatrix[i][i] = true;
}

// DP to check every substring of s is palindrome or not?
// substring length start from 2 to n
for (int L = 2; L <= len; L++) {
for (int i = 0; i < len - L + 1; i++) {
int j = i + L - 1;
if (L == 2) {
palindromeMatrix[i][j] = (s.charAt(i) == s.charAt(j));
} else {
palindromeMatrix[i][j] = (s.charAt(i) == s.charAt(j) && palindromeMatrix[i + 1][j - 1]);
}
}
}

for (int i = len - 1; i >= 0; i--) {
if(palindromeMatrix[i][len - 1]){
dp[i] = 0;
} else {
int min = Integer.MAX_VALUE;
for (int k = i + 1; k < len; k++) {
if(palindromeMatrix[i][k - 1])
min = Math.min(min, 1 + dp[k]);
}
dp[i] = min;
}
}
return dp[0];
}

陈立人的博客里面说到：不太明白如何构建树来解决这个问题http://www.ituring.com.cn/article/57155回文字串判断完毕之后，改如何计算最少分割呢？我们可以根据P构建一棵树，然后宽度有限遍历，找到树的最小深度。上面判断回文的时间复杂度为 O(n^2)，构建树的时间复杂度为遍历一次P，时间复杂度也是O(n^2)，最后树的遍历，时间复杂度要小于O(n^2)，这样，整体的时间复杂度为 O(n^2)。