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)

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值