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)