题目1 :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",
[ ["aa","b"], ["a","a","b"] ]
题目2:
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", Return1since the palindrome partitioning["aa","b"]could be produced using 1 cut.
题目1给出两个解法:都是DFS深度优先搜索(用递归),第一个是我写的,后来看第二个想法特别简介,也写了一次。
1(被注释的):主函数先构造一个 dp[i][j] ,含义是从i到j的字符范围内是不是回文序列,是的话true,反义false ,它是一个半边的方阵。然后主函数中循环dp[i]中为true的,含义是从第一个字符开始的回文都遍历一遍。另一个函数dfspart()中先判断start达没达到总串s的长度,达到了就把一组答案tmp压入结果result中,然后返回。start记录的是一个位置,start前面的回文已经判断完了,从start向后找回文,还是循环dp[start]中为true的位置,再次用dfs函数找后一个位置。
2:第二个解法思想还是一样的,好处1是每次输入的s不是整个串了,而是把前面已经判断过的回文截断,(上一个解法是用总串s和start来解决这个问题)。好处2是不用先构造dp了,在dfs内用一个begin和end来判断部分子串是不是回文,是的话再用dfs遍历下一段s,不是的话就不用管它了。
class Solution {
public:
/* vector<vector<string>> partition(string s) {
vector<vector<string> > result;
int n=s.length();
vector<vector<bool> > dp(n,vector<bool>(n,false));
for(int i=0;i<n;++i){
for(int j=i;j<n;++j){
string part=s.substr(i,j-i+1);
string partcopy=part;
reverse(part.begin(),part.end());
if(part==partcopy)
dp[i][j]=true;
}
}
for(int i=0;i<n;i++){
if(dp[0][i]){
vector<string> tmp;
tmp.push_back(s.substr(0,i+1));
dfspart(result,dp,i+1,tmp,s);
}
}
return result;
}
void dfspart(vector<vector<string> > &result,vector<vector<bool> > &dp,
int start,vector<string> &tmp,string &s){
if(start>=s.length()){
result.push_back(tmp);
return;
}
for(int i=start;i<s.length();++i){
if(dp[start][i]){
tmp.push_back(s.substr(start,i-start+1));
dfspart(result,dp,i+1,tmp,s);
tmp.pop_back();
}
}
} */
void dfs(string s,vector<vector<string>> &result,vector<string> &path){
if(s.length()==0) {
result.push_back(path);
return;
}
for(int i=0;i<s.length();i++){
int begin=0;
int end=i;
while(begin<end){
if(s[begin]==s[end]){
begin++;end--;
}else
break;
}
if(begin>=end){
path.push_back(s.substr(0,i+1));
dfs(s.substr(i+1),result,path);
path.pop_back();//注意是用的path引用,要弹出一个
}
}
}
vector<vector<string>> partition(string s) {
vector<vector<string>> result;
vector<string> path;
dfs(s,result,path);
return result;
}
};
题目2也写了两个解法,第一个被注释掉的就是题目1的方法,但是不能通过超时了,第二个是动态规划思想。先构造个dp[][],和上文的含义一样,不过构造方式我借用了别人的写法,很巧妙,也类似于动态规划,不用像之前的写法每次判断一下子串是不是回文,再赋值为true或flase。再构造个count ,其实这个count的逐步构造才是这个题最根本的动态规划思想,具体的解释写在注释里了。
class Solution {
public:
/* 内存超限
int minCut(string s) {
vector<vector<string>> result;
vector<string> path;
dfs(s,result,path);
int min=result[0].size();
for(int i=1;i<result.size();++i){
if(result[i].size()<min){
min=result[i].size();
}
}
return min-1;
}
void dfs(string s,vector<vector<string>> &result,vector<string> &path){
if(s.length()==0) {
result.push_back(path);
return;
}
for(int i=0;i<s.length();i++){
int begin=0;
int end=i;
while(begin<end){
if(s[begin]==s[end]){
begin++;end--;
}else
break;
}
if(begin>=end){
path.push_back(s.substr(0,i+1));
dfs(s.substr(i+1),result,path);
path.pop_back();
}
}
}
*/
int minCut(string s) {
int n=s.length();
if (0==n) return 0;
vector<vector<bool>> dp(n,vector<bool>(n,false));
vector<int> count(n+1);
count[0]=0;
count[1]=1;
for(int j=0;j<n;++j)
for(int i=0;i<=j;++i){
dp[i][j]=(s[i]==s[j])&&( j-i<=2 || dp[i+1][j-1] );
//从i到j是不是回文,必须外循环是j
}
//例如,5个字符的最小分割数量取决于:<前4个字符的最小分割数量+1>或者
//<后两个是不是回文:(不是的话不用管它)是的话,前3个字符的最小分割数量+1> 或者
//<后三个是不是回文:(不是的话不用管它)是的话,前2个字符的最小分割数量+1> 或者
//<后四个是不是回文:(不是的话不用管它)是的话,前1个字符的最小分割数量+1> 或者
//<后五个是不是回文:(不是的话不用管它)是的话,前0个字符的最小分割数量+1>
//(这里前0个字符的最小分割是0,前1个字符的最小分割是1)初始化的 可以理解吧
//注意上边的ij是s的下标是s[i] s[j]表示位置。
//注意下面的ij是第i个第j个字符,第0个其实是不存在的,对应count[0]=0,代表前0个字符的最小分割数量是0
for(int i=2;i<n+1;++i){
count[i]=count[i-1]+1;//<前i-1个字符的最小分割数量+1>
for(int j=i-1;j>=1;--j){
if(dp[j-1][i-1]){
count[i]=min(count[j-1]+1,count[i]);
}else{
//这里对应上边说的(不是的话不用管它)
}
}
}
return count[n]-1;//分割数量-1是切了几刀
}
};