LeetCode:Palindrome Partitioning,Palindrome Partitioning II

LeetCode:Palindrome Partitioning

题目如下：（把一个字符串划分成几个回文子串，枚举所有可能的划分）

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

分析：首先对字符串的所有子串判断是否是回文，设f[i][j] = true表示以i为起点，长度为j的子串是回文,等于false表示不是回文，那么求f[i][j]的动态规划方程如下：

• 当j = 1，f[i][j] = true;

• 当j = 2，f[i][j] = (s[i]==s[i+1]),其中s是输入字符串

• 当j > 2, f[i][j] = f[i+1][j-2] && (s[i] == s[i+j-1])（即判断s[m..n]是否是回文时：只要s[m+1...n-1]是回文并且s[m] = s[n]，那么它就是回文，否则不是回文）

这一题也可以不用动态规划来求f，可以用普通的判断回文的方式判断每个子串是否为回文。                                                                                                               本文地址

求得f后，根据 f 可以构建一棵树，可以通过DFS来枚举所有的分割方式，代码如下：

 class Solution {
 public:
     vector<vector<string>> partition(string s) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         vector< vector<string> >res;
         int len = s.length();
         if(len == )return res;
         //f[i][j] = true表示以i为起点，长度为j的子串是回文
         bool **f = new bool*[len];
         for(int i =  ; i < len; i++)
         {
             f[i] = new bool[len+];
             for(int j = ; j < len+; j++)
                 f[i][j] = ;
             f[i][] = true;
         }
         for(int k = ; k <= len; k++)
         {
             for(int i = ; i <= len-k; i++)
             {
                 if(k == )f[i][] = (s[i] == s[i+]);
                 else f[i][k] = f[i+][k-] && (s[i] == s[i+k-]);
             }
         }
         vector<string> tmp;
         DFSRecur(s, f, , res, tmp);
         for(int i =  ; i < len; i++)
             delete [](f[i]);
         delete []f;
         return res;
     }

     void DFSRecur(const string &s, bool **f, int i,
             vector< vector<string> > &res, vector<string> &tmp)
     {//i为遍历的起点
         int len = s.length();
         if(i >= len){res.push_back(tmp); return;}
         for(int k = ; k <= len - i; k++)
             if(f[i][k] == true)
             {
                 tmp.push_back(s.substr(i, k));
                 DFSRecur(s, f, i+k, res, tmp);
                 tmp.pop_back();
             }

     }
 };

---

LeetCdoe: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.                                                                                                          本文地址

算法1：在上一题的基础上，我们很容易想到的是在DFS时，求得树的最小深度即可（遍历时可以根据当前求得的深度进行剪枝），但是可能是递归层数太多，大数据时运行超时，也贴上代码：

 class Solution {
 public:
     int minCut(string s) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = s.length();
         if(len <= )return ;
         //f[i][j] = true表示以i为起点，长度为j的子串是回文
         bool **f = new bool*[len];
         for(int i =  ; i < len; i++)
         {
             f[i] = new bool[len+];
             for(int j = ; j < len+; j++)
                 f[i][j] = ;
             f[i][] = true;
         }
         for(int k = ; k <= len; k++)
         {
             for(int i = ; i <= len-k; i++)
             {
                 if(k == )f[i][] = (s[i] == s[i+]);
                 else f[i][k] = f[i+][k-] && (s[i] == s[i+k-]);
             }
         }
         int res = len, depth = ;
         DFSRecur(s, f, , res, depth);
         for(int i =  ; i < len; i++)
             delete [](f[i]);
         delete []f;
         return res - ;
     }
     void DFSRecur(const string &s, bool **f, int i,
             int &res, int &currdepth)
     {
         int len = s.length();
         if(i >= len){res = res<=currdepth? res:currdepth; return;}
         for(int k = ; k <= len - i; k++)
             if(f[i][k] == true)
             {
                 currdepth++;
                 if(currdepth < res)
                     DFSRecur(s, f, i+k, res, currdepth);
                 currdepth--;
             }

     }

 };

算法2：设f[i][j]是i为起点，长度为j的子串的最小分割次数，f[i][j] = 0时，该子串是回文，f的动态规划方程是：

f[i][j] = min{f[i][k] + f[i+k][j-k] +1} ,其中 1<= k <j

这里f充当了两个角色，一是记录子串是否是回文，二是记录子串的最小分割次数，可以结合上一题的动态规划方程，算法复杂度是O(n^3), 还是大数据超时，代码如下：

 class Solution {
 public:
     int minCut(string s) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = s.length();
         if(len <= )return ;
         //f[i][j] = true表示以i为起点，长度为j的子串的最小切割次数
         int **f = new int*[len];
         for(int i =  ; i < len; i++)
         {
             f[i] = new int[len+];
             for(int j = ; j < len+; j++)
                 f[i][j] = len;
             f[i][] = ;
         }
         for(int k = ; k <= len; k++)
         {
             for(int i = ; i <= len-k; i++)
             {
                 if(k ==  && s[i] == s[i+])f[i][] = ;
                 else if(f[i+][k-] ==  &&s[i] == s[i+k-])f[i][k] = ;
                 else
                 {
                     for(int m = ; m < k; m++)
                         if(f[i][k] > f[i][m] + f[i+m][k-m] + )
                             f[i][k] = f[i][m] + f[i+m][k-m] + ;
                 }
             }
         }
         int res = f[][len], depth = ;
         for(int i =  ; i < len; i++)
             delete [](f[i]);
         delete []f;
         return res;
     }
 };

算法3：同上一题，用f来记录子串是否是回文，另外优化最小分割次数的动态规划方程如下,mins[i] 表示子串s[0...i]的最小分割次数：

• 如果s[0...i]是回文，mins[i] = 0
• 如果s[0...i]不是回文，mins[i] = min{mins[k] +1 (s[k+1...i]是回文)  或  mins[k] + i-k  (s[k+1...i]不是回文)} ，其中0<= k < i

代码如下，大数据顺利通过，结果Accept：                                                                                                                                 本文地址

 class Solution {
 public:
     int minCut(string s) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         int len = s.length();
         if(len <= )return ;
         //f[i][j] = true表示以i为起点，长度为j的子串是回文
         bool **f = new bool*[len];
         for(int i =  ; i < len; i++)
         {
             f[i] = new bool[len+];
             for(int j = ; j < len+; j++)
                 f[i][j] = false;
             f[i][] = true;
         }
         int mins[len];//mins[i]表示s[0...i]的最小分割次数
         mins[] = ;
         for(int k = ; k <= len; k++)
         {
             for(int i = ; i <= len-k; i++)
             {
                 if(k == )f[i][] = (s[i] == s[i+]);
                 else f[i][k] = f[i+][k-] && (s[i] == s[i+k-]);
             }
             if(f[][k] == true){mins[k-] = ; continue;}
             mins[k-] = len - ;
             for(int i = ; i < k-; i++)
             {
                 int tmp;
                 if(f[i+][k-i-] == true)tmp = mins[i]+;
                 else tmp = mins[i]+k-i-;
                 if(mins[k-] > tmp)mins[k-] = tmp;
             }
         }
         for(int i =  ; i < len; i++)
             delete [](f[i]);
         delete []f;
         return mins[len-];
     }

 };

 【版权声明】转载请注明出处：http://www.cnblogs.com/TenosDoIt/p/3421283.html