leetcode 131 Palindrome Partitioning

https://leetcode.com/problems/palindrome-partitioning/#/description

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”]
]

题目分析：题目要求将一个字符串分成回文的组合，需要求出所有的符合要求的组合。比如字符串 aab 有两种组合: aa, b 和 a, a, b。其中 aa, b, a 都是回文。

可以将问题分解成两个子问题：如何分割字符串 和 判断子串是否为回文。

判断回文的方法
先说说简单的问题：判断回文的方法。

判断回文有三种方法：双指针、递归 和 Reverse 字符串。

双指针是通过两个指针，分别指向字符串的首尾，如果当前的两个字符相等则继续，直到两个指针相遇（或者位置相差 1）。

def is_palindrome(s)
    i, j = 0, s.length - 1
    while i < j do
        return false if s[i] != s[j]
        i += 1
        j += 1
    end
    return true
end

递归的思路跟双指正类似：当前字符串是否为回文取决于首尾两个字符是否相等 和 除去首尾两个字符的子串是否为回文。

def is_palindrome(s)
    return true if s.length == 0 || s.length == 1
    s[0] == s[-1] && is_palindrome(s[1..-2])
end

Reverse 字符串的思路就是字符串反转后判断是否与原串相等，一般动态语言的字符串都有反转字符串的API，所以代码最简单。

def is_palindrome(s)
    s == s.reverse 
end

*如何分割字符串*
分割字符串比较简单，可以用两种方式分割：其一，将字符串 AB 分割成 A + B连个字符串，会产生新的字符串，比如 abc 可以分割成 a + bc, ab + c, a + b + c；其二，用一个下标表示字符串的分割位置，这种方式没有实际的分割字符串，只是用了一个标识位。

方法一：暴力回溯

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> str;
        vector<string> tmp;
        subString(s,tmp,str,0);
        return str;
    }

    bool isPalindrome(const string &s , int start , int end){
        while(start < end && s[start] == s[end]){
            start ++ ;
            end --;
        }
        return start >= end;
    }
    //subString分解串，start记录剩余串的位置，tmp记录找到的串
    void subString(string &s , vector<string> &tmp , vector<vector<string>> &str , int start){
        if(start == s.size()){
            str.push_back(tmp);
            return ;
        }
        for(int i = start ; i<s.size() ; i++)
        if(isPalindrome(s,start,i)){
            tmp.push_back(s.substr(start , i-start+1));
            subString(s,tmp,str,i+1);
            tmp.pop_back();//回溯后一定把以前的结果移除
        }
    }

};

方法二： 动态规划
dp(j, i) = s[i] == s[j] && dp(j+1, i-1)
dp(j,i) 表示下标 j 到 下标 i 的子串是否是回文
从leetcode借鉴过来的，执行效率很高

public class Solution {
    public static List<List<String>> partition(String s) {
        int len = s.length();
        List<List<String>>[] result = new List[len + 1];
        result[0] = new ArrayList<List<String>>();
        result[0].add(new ArrayList<String>());

        boolean[][] pair = new boolean[len][len];
        for (int i = 0; i < s.length(); i++) {
            result[i + 1] = new ArrayList<List<String>>();
            for (int left = 0; left <= i; left++) {
                if (s.charAt(left) == s.charAt(i) && (i-left <= 1 || pair[left + 1][i - 1])) {
                    pair[left][i] = true;
                    String str = s.substring(left, i + 1);
                    for (List<String> r : result[left]) {
                        List<String> ri = new ArrayList<String>(r);
                        ri.add(str);
                        result[i + 1].add(ri);
                    }
                }
            }
        }
        return result[len];
    }
}

方法三 ：递归
递归的思路跟暴力搜索有些许不同：将字符串分成 A + B两个部分，如果 A 是回文，我们只需要求出 B 的所有回文的组合就行，然后将 A 和 B 结果做笛卡尔乘积就行了。

比如求 aaab 的所有回文组合：
将字符串分割成 a + aab， a 子串是回文， aab子串的回文组合是 [a, a, b], [aa, b]， 所以合并组合: [a, a, a, b], [a, aa, b]
将字符串分割成 aa + ab, aa 子串是回文， ab 子串的回文组合是 [a, b]， 所以合并组合: [aa, a, b]

public class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> res = new ArrayList<>();
        if(s == null || s.length() == 0) return res;

        if(isPalidrome(s)){
            List<String> list = new ArrayList();
            list.add(s);
            res.add(list);
        }
        for(int i = 1 ; i<s.length() ; i++){
             String left = s.substring(0,i);
             if(isPalidrome(left)){
                 String right = s.substring(i);
                 List<List<String>>rights = partition(right);
                 if(rights.size() > 0){
                    for(int j = 0 ; j <rights.size() ; j++){
                         List<String> list = new ArrayList<>();
                        list.add(left);
                        list.addAll(rights.get(j));
                        res.add(list);
                    }
                 }
             }
        }
        return res;

    }

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