Leetcode: Palindrome Partitioning I & II

Problem I : Palindrome Partitioning I 

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

Solve the problem on Leetcode 

分析：

（方法1）

这道题拿过来以后第一感觉很像我们之前解决的 Restore IP Address 这道题。

回忆一下那道题，传入一串字符串，要我们验证是否是合法的IP地址。IP地址分4个Part，每个Part能取1,2或者3个字符，对于每个截取的片段，我们要判断是否在0-255之间。

那再看这道题，有什么区别呢，

1.  我们可以分任意个Part，只要每个Part保证是Palindrome就行

2. 每个Part可以取任意长的字符（从这个字符开始，取1个，取2个，一直到取到字符结尾）

相同点在于我们同样需要一个isValid函数来判断截取的字符是否是palindrome

代码如下 ：

public class Solution {
    public ArrayList<ArrayList<String>> partition(String s) {
        ArrayList<ArrayList<String>> res = new ArrayList<ArrayList<String>>();
        ArrayList<String> tmp = new ArrayList<String>();
        dfs(res,tmp,s);
        return res;
    }
    
    public void dfs(ArrayList<ArrayList<String>> res, ArrayList<String> tmp, String s){
        if (s.length()==0) res.add(new ArrayList<String>(tmp));
        for(int i=1;i<=s.length();i++){
            String substr = s.substring(0,i);
            if(isPalindrome(substr)){
                tmp.add(substr);
                dfs(res,tmp,s.substring(i));
                tmp.remove(tmp.size()-1);
            }
        }    
    }
    
    public boolean isPalindrome(String s){
        int i = 0;
        int j = s.length()-1;
        while(i<j){
            if (s.charAt(i++) != s.charAt(j--)) return false;
        }
        return true;
    }
}

因为每个Part长度任意，循环里就需要从1开始一直到这一层传进的字符的结尾。

在dfs里，当我们验证了从[0,i) 是合法的Palindrome后，在下一层我们判断剩下的字符串就好，所以dfs里面要传入s.substring(i)

验证每个字符串是否是Palindrome的时候，字符串首尾两个指针同时往中间走进行比较

（方法2）

除了上面直接的dfs之外，其实可以观察到验证一个字符串里都有哪些子字符串是Palindrome，其实是一个DP问题。

我们不妨以总的字符串的长度Len，创建一个boolean[][] T = new boolean[len][len]; 用它来表示从某个字符开始到某个字符终止是不是Palindrome

比如 T[i][j] 表示什么呢？ 表示从字符串s的第i位开始，一直到字符串的第j位所形成的子字符串是否是Palindrome

这么一来，我们就需要确立base case 和推倒公式

首先，我们知道一个字符，它本身就是Palindrome，所以再这个矩阵中，对角线上的元素T[i][i]全部都是True 

然后我们想，在知道一个字符是Palindrome后，在这个字符左边添上一个字符，在这个字符右边添上一个字符，要想使这三个字符成为Palindrome的条件为：

左边的字符 = 右边的字符 

T[i-1][i+1] = true, only if  s.charAt(i-1) == s.charAt(i+1) 

T[i-1][i+1] 中的第一个变量i-1表示字符串的起始位置往前挪动一个，第二个变量i+1表示字符串的结束位置往后挪动一个

在这个基础上，我们可以再把字符串伸展，继续重复这个步骤，直到超出字符串的范围

当然，除了字符串为奇数个的情况，我们同样要考虑字符串为偶数个的情况，我们画一个图来说明：

(图1)                     (图2)                   (图3)

如图1， 

比如我们从T[2][2] = 'C' 这个字母开始，s.charAt(1) = s.charAt(3) 左右两边各添一个'B'，成立。

现在我们知道T[1][3] = true "aba"是Palindrome，我们继续在两边添加字符s.charAt(0)!=s.charAt(4) 左边添一个'A',右边添一个'C'，不成立。

如图2， 

长度为奇数的字符串在每个循环里的判断如图中的黑色箭头，长度为偶数的字符串在每个循环里的判断如图中的红色箭头。

唯一的区别就在于每次循环奇数串的起点是left = i - 1, right = i + 1，偶数串是left = i - 1, right = i

最终完成图如图3所示

那好，现在我们有了字符串Palindrome矩阵，怎么输出每一种Palindrome的组合呢？

我们继续用熟悉的dfs求解，像之前dfs的题一样，我们传入一个int pos变量，每次循环里i从pos开始，一直到s.length为止，若发现T[pos][i] 字串为真，下一次递归pos就从i结尾后面开始，即传入pos的参数为i + 1. 而当pos = s.length()的时候，我们便找到一组解。

代码如下：

public class Solution {
    public ArrayList<ArrayList<String>> partition(String s) {
        ArrayList<ArrayList<String>> res = new ArrayList<ArrayList<String>>();
        ArrayList<String> tmp = new ArrayList<String>();
        dfs(res,tmp,s,table(s),0);
        return res;
    }
    
    public void dfs(ArrayList<ArrayList<String>> res, ArrayList<String> tmp, String s, boolean[][] T, int pos){
        if (pos==s.length()) res.add(new ArrayList<String>(tmp));
        for(int i=pos;i<s.length();i++){
            if(T[pos][i]){
                tmp.add(s.substring(pos,i+1));
                dfs(res,tmp,s,T,i+1);
                tmp.remove(tmp.size()-1);
            }
        }
    }
    
    public boolean[][] table(String s){
        boolean[][] T = new boolean[s.length()][s.length()];
        for(int i=0;i<s.length();i++){
            T[i][i] = true;
        }
        for(int i=0;i<s.length();i++){
            //even
            int l = i - 1;
            int r = i;
            while(l>=0 && r<s.length() && s.charAt(l)==s.charAt(r))
                T[l--][r++] = true;
            //odd
            l = i -1;
            r = i + 1;
            while(l>=0 && r<s.length() && s.charAt(l)==s.charAt(r))
                T[l--][r++] = true;
        }
        return T;
    }
}

Problem 2 : 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.

分析： 

这个题是在上一个题的基础上继续问，返回所有分割中最小分割数

这个题很多人都分析过了，其实是两个合在一起的DP，其中一个DP绘制字符子串Palindrome矩阵，我们已经解决了。那么剩下的问题就是怎么求最小切数了

我们从字符串的尾巴往前推，我们来创造一个dp数组，叫cut[]，在数组里cut[i] 表示从字符串第i位开始到字符串结尾需要切的刀数（包括该i位左边的一刀）

假设，不幸的是，从第i位开始到后面都不存在Palindrome，那么需要的刀数就为 len - i (包括左边的一刀)，即每个字符间都要切一刀

那么我们从第i位开始，往后找，设计一个循环一直到字符串结尾，看是否存在Palindrome

            for(int j=i;j<len;j++){
                if (T[i][j]){
                        cut[i] = Math.min(cut[i],1+cut[j+1]);
                }
            }

如果发现T[i][j]是一个Palindrome，那么从T[i][j]我们中间就不用切刀啦，然后去加上j位后面一位需要切刀的数量（+1是因为要保存最左边的一刀），然后我们和之前的cut[i]这一位进行比较，如果比之前的刀数少，我们便保留这个值，在循环到结尾的过程中一直最小值就能保证第i位以后的字串保持最小切刀数目，一直到cut[0]为止，最后因为第一个字符最左边不需要切，我们返回cut[0] - 1

代码如下：

public class Solution {
    public int minCut(String s) {
        // Start typing your Java solution below
        // DO NOT write main() function
        int len = s.length();
        boolean[][] T = creatTable(s); 
        int[] cut = new int[len+1]; //创建len+1长度的数组是为了能验证到最后一位
        cut[len] = 0;
        for(int i=len-1;i>=0;i--){
            cut[i] = len - i;
            for(int j=i;j<len;j++){
                if (T[i][j]){
                        cut[i] = Math.min(cut[i],1+cut[j+1]);
                }
            }
        }
        return cut[0] - 1;
    }
    //创建第一问里面的Palindrome矩阵
    public boolean[][] creatTable(String s){
        boolean[][] T = new boolean[s.length()][s.length()];
        for(int i=0;i<s.length();i++){
            T[i][i] = true;
        }
        for(int i=0;i<s.length();i++){
            //even
            int l = i - 1;
            int r = i;
            while(l>=0 && r<s.length() && s.charAt(l)==s.charAt(r))
                T[l--][r++] = true;
            //odd
            l = i -1;
            r = i + 1;
            while(l>=0 && r<s.length() && s.charAt(l)==s.charAt(r))
                T[l--][r++] = true;
        }
        return T;
    }
}

参考文章：  

http://n00tc0d3r.blogspot.com/2013/05/palindrome-partitioning.html?q=palindrome

http://blog.sina.com.cn/s/blog_b9285de20101iwqt.html (from Peking2)