分割回文串

回文回文串

“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”以及“a”等等就是回文串。

分割回文串（一）

题目描述

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。返回符合要求的最少分割次数。

示例：
输入: "aab"
输出: 1
解释: 进行一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。

思路分析

假设字符串s的长度为n，先确定字符串s在[0,i]上符合要求的最小分割次数,记为dp[i]（i不大于n）。那么当i=n时，就是最后的结果。那么怎么求dp[i]呢？假设j是0~i上的中间位置，且[j,i]上是回文，那么意味着有可能在j-1和j处进行分割一次，dp[i]也就可能等于[0,j-1]上的最优分割次数再加上1，也即dp[j-1]+1;dp[i]最终的值应该是所有这些情况中最小的那个，也即：dp[i]=min(dp[j-i]+1) (0<=j<=i)。
根据这种思路可以写出一个暴力递归版本的解答，虽然结果正确，但是复杂情况下程序运行超时。

  class Solution {
    public:
        int minCut(string s) {
            int n=s.length();
            if(n==0)
                return -1;
            return dp(s,n-1);
        }
        int dp(string s,int i) {
            if(i<=0)
                return 0;
            int res=INT_MAX;
            for(int j=i;j>=0;j--){
                if(ispalindrome(s.substr(j,i-j+1))){
                    res=min(res,j==0?0:(dp(s,j-1)+1));
                }
            }
            return res;
        }
        bool ispalindrome(string s){
            return s==string(s.rbegin(),s.rend());
        }
    };

因此可以将其改写为动态规划的形式：可以用一个长度为n的dp数组记录[0,i]上的最小分割次数，最终返回结果为dp[n-1]。

还有一个问题就是怎么快速确认[j,i]上是回文串?s[i]=s[j]且i-j<2,则一定是回文串；i-j>=2时，如果 s[i]=s[j]且[j+1,i-1]上是回文串，那么[j,i]上一定是回文串；根据这个思路，可以用一个n*n的二维数组p记录[j~i]上是不是回文串。

动态规划版本的c++代码如下：

      int minCut(string s) {
           int n=s.size();
           vector<int> dp(n,INT_MAX);
           vector<vector<bool> > p(n,vector<bool>(n,false));
           for(int i=0;i<n;i++)
           {
               for(int j=i;j>=0;j--)
               {
                   if((s[i]==s[j])&&(i-j<2||p[i-1][j+1]))
                   {
                       p[i][j]=true;
                       if(j==0)
                           dp[i]=0;
                       else
                           dp[i]=min(dp[i],dp[j-1]+1);
                   }
               }
           }
           return dp[n-1];
       }

分割回文串（二）

题目描述

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
返回 s 所有可能的分割方案。

示例：
输入: "aab"
输出:
[
  ["aa","b"],
  ["a","a","b"]
]

思路分析

由于需要输出所有分割结果，一般采用深度优先遍历，利用递归的方法保存所有的结果。深度优先遍历是沿着一条路径搜索到结束，再换另一条不同的路径继续搜索。这段代码虽然很短，但是却足够看很久了，写的的确很精彩。

  class Solution {
       public:
       vector<vector<string>> partition(string s) {
           vector<vector<string>> res;
           vector<string> cur;
           dfs(s,cur,res); 
           return res;
       } 
       bool isPalindrome(string s){
           return s==string(s.rbegin(),s.rend());
       }
       void dfs(string s,vector<string> &cur,vector<vector<string>> &res){
           if (s==""){
               res.push_back(cur);
               return;
           }
           for (int i = 1; i <= s.length(); ++i) {
               string sub=s.substr(0,i);
               if (isPalindrome(sub)){
                   cur.push_back(sub);
                   dfs(s.substr(i,s.length()-i),cur,res);
                   cur.pop_back();
               }
           }
       }
   };

总结

一般的，如果是求最优解或者是解的个数，会采用动态规划(Dynamic Programing,DP)的方法；如果需要保存所有可能的解，则一般采用深度优先遍历(Depth-First Traversal,DFS)或者回溯法。

---

关注微信公众号【德古拉的杂货铺】