Leetcode - 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"]
  ]

基础解法，采用backstrack实现：

public class Solution {
    private boolean[][] palindrome = null;
    public ArrayList<ArrayList<String>> partition(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int length = s.length();
        palindrome = new boolean[length][length];
        for (int i=0; i<length; i++)
            for (int j=i; j<length; j++) {
                boolean isPalin = true;
                int si = i, sj=j;
                while (si < sj) {
                    if (s.charAt(si++) != s.charAt(sj--)) {
                        isPalin = false;
                        break;
                    }
                }
                palindrome[i][j] = isPalin;
            }
            
        return bs(s, 0, length-1);
    }
    
    public ArrayList<ArrayList<String>> bs(String s, int start, int stop) {
        ArrayList<ArrayList<String>> ret = new ArrayList<ArrayList<String>>();
        for (int i=start; i<=stop; i++)
            if (isPalindrome(start, i)) {
                if (i == stop) {
                     ArrayList<String> value = new ArrayList<String>();
                     value.add(s.substring(start, stop+1));
                     ret.add(value);
                } else {
                    String str = s.substring(start, i+1);
                    ArrayList<ArrayList<String>> leftList = bs(s, i+1, stop);
                    for (int j=0; j<leftList.size(); j++) {
                        ArrayList<String> split = leftList.get(j);
                        split.add(0, str);
                        ret.add(split);
                    }
                }
            }
        return ret;
    }
    
    public boolean isPalindrome(int i, int j) {
        return palindrome[i][j];
    }
}

能通过Leetcode Judge Samll test cases:

input	output	expected	
"a"	[["a"]]	[["a"]]	
   
"ab"	[["a","b"]]	[["a","b"]]	
   
"bb"	[["b","b"],["bb"]]	[["b","b"],["bb"]]	
   
"cdd"	[["c","d","d"],["c","dd"]]	[["c","d","d"],["c","dd"]]	
   
"dde"	[["d","d","e"],["dd","e"]]	[["d","d","e"],["dd","e"]]	
   
"efe"	[["e","f","e"],["efe"]]	[["e","f","e"],["efe"]]	
   
"fff"	[["f","f","f"],["f","ff"],["ff","f"],["fff"]]	[["f","f","f"],["f","ff"],["ff","f"],["fff"]]	
   
"abbab"	[["a","b","b","a","b"],["a","b","bab"],["a","bb","a","b"],["abba","b"]]	[["a","b","b","a","b"],["a","b","bab"],["a","bb","a","b"],["abba","b"]]	
   
"leet"	[["l","e","e","t"],["l","ee","t"]]	[["l","e","e","t"],["l","ee","t"]]	
   
"coder"	[["c","o","d","e","r"]]	[["c","o","d","e","r"]]

经过测试，也能通过Large Judge test cases。

关于时间复杂度，该算法的isPalindrome部分时间复杂度为N^3，回溯部分时间复杂度为：

f(n) = f(n-1)+f(n-2)+f(n-3)+...+f(1)

=2 * ( f(n-2)+f(n-3)+...+f(1) )

=4 * ( f(n-3) + ... + f(1) )

=2^n

但能通过Large Judge test cases,是因为测试数据太不刁钻,如果测试数据为这样的一个串“aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa”

程序运行时间将会变的非常长，实验结果如下：

字符串长度  结果条目数 动行时间ms

14 result:8192 time cost:19

15 result:16384 time cost:35

16 result:32768 time cost:85

17 result:65536 time cost:186

18 result:131072 time cost:421

19 result:262144 time cost:920

可以看出，程序运行时间呈指数型增长。。。。再想想有没有好点的办法解决这个问题吧。。。