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.

参考：

http://blog.csdn.net/doc_sgl/article/details/13418125

http://blog.csdn.net/u011095253/article/details/9177451

采用俩次dp ！！而且嵌套！

f(j+1) 为j之后的最小刀切数，而f(i) 为j前第一个增加刀数的。即中间出现回文！min(f(i),f(j+1)+1)  ，从而中间必是最大回文！！

还有此题回文若通过不断通过简单回文比较（即俩小标从俩边到中间比较的方法）时间复杂度将会难以接受！！！

感觉此题难度不小！还需以后再看！！

   // 递推公式： f(i,j) = min(f(i,k)+f(k+1,j)) ; i<j<n
   //简化为一维，尾端为n，f(i)为i到n的最小切割数
   //先赋予f(i)最差情况为len-i 刀
   //f(i) = min(f(i),f(j+1)+1) i<=j<n   //如下假如j为分界处，所以f(j+1)需补上一刀 （在之前的值上进行更新！）
   // 11  10  9   8   7   6   5   4   3   2   1   0    -1  -----》初始值
   // a   b   a   b   b   b   a   b   b   a   b   a
   //                 i                           n
   //
   // a   b   a   b   b   b   a   b   b   a   b   a
   //                 i               j   j+1     n
   //
   // 即i-j之间是回文，所以j+1,所以另需一个回文判断！dp算法  ->>isPalind[i][j]  ij 之间是回文
   //isPalind[i][j] = str[i] == str[j] && isPalind[i+1][j-1];
   //
    int minCut(string s) {
        
        int length = s.size();
        
        int f[length+1] ;
        bool isPalind[length][length];
        
        memset(isPalind,false,sizeof(bool)*length*length);
        
        f[length] = -1;
        for(int k = 0 ; k <= length - 1 ;k++)
        {
            f[k] = length - 1 - k;
        }
        
        for(int i = length - 1 ; i >= 0 ;i--)
        {
            for(int j = i ; j < length ;j++)
            {
                if(s[i] == s[j] &&(j-i < 2 || isPalind[i + 1][j - 1]))//是回文   //j-i < 2 为（第一种是一个字符，俩个字符且相等！）
                {
                    isPalind[i][j] = true;
                    f[i] = min(f[i] , f[j + 1]+1);
                }
                
            }
            
        }
        
        return f[0];
    }

第二次：14-7-2 

此处重写了下，从前面开始。思路将字符串分为俩部分，前面为以验证过的划分，后半段判断是否为回文，是则更新划分。

如 aabbaa

正常 dp[i] （为i位置所需划分数）分别为 0,1,2,3,4,5  

dp[i] 代表当前0到第i个元素的划分， 【0-1】闭区间。j代表第j个元素开始,用于定位从j开始到i的回文。所以dp[j-1]为前半段的划分（回文之前）。

当i = 1 时 会从j = 0 开始更新 dp[i]. 此时 j 之前为特殊情况不用管，只需判断后面[i,j]的元素，若是回文，划分为0 ，得dp[1]=0。j= 1时，a=a,划分更新dp[j-1]+1为1.前面已经最小 dp[1]仍为0.

当i = 2时 ，j= 0时，a！=b,则继续,  当j = 1时，a！=b,则继续。当j=2时，b = b, 而aa 之前验证为dp[1]=0.所以此时dp[1]+1 =1

   int minCut(string s) 
    {
       vector<vector<bool>> ispalind(s.size(),vector<bool>(s.size(),false));
       vector<int> dp(s.size());
       
       if(s.size() == 1) return 0;
 
       for(int i = 0; i < s.size();i++)
       {
           dp[i] = i;//刚好n个元素n-1 刀
       }
       
       for(int i = 1; i < s.size();i++)
       {
          for(int j = 0; j <= i;j++)
          {
             
              if((s[i] == s[j])&&(i-j < 2 || ispalind[i-1][j+1]))
              {
                  ispalind[i][j] = true;
                  if(j >= 1)
                  {
                     dp[i] = min(dp[j-1]+1,dp[i]);//前半段的划分，加后半段为回文故而加1!
                  }
                  else//特殊情况当j = 0 表示之前没有元素！有后面为回文故而为0
                  {
                      dp[i] = 0;
                  }
              }
              
          }
       }
       return dp[s.size()-1];
    }