Palindrome Partitioning I 和II的代码和理解(动态规划思想)

题目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是切了几刀
    }
};