动规应用——第七题回文串的分割

回文串分割

动态规划——困难

回文串分割

给出一个字符串s，分割s使得分割出的每一个子串都是回文串

计算将字符串s分割成回文分割结果的最小切割数

例如:给定字符串s=“aab”,

返回1，因为回文分割结果[“aa”,“b”]是切割一次生成的。

动态规划

问题：

​ 分割字符串，使其每个子串都是回文串，返回最小分割次数

状态分析：

​ 子问题：以第i个字符为结尾的字符串，最小分割次数

​ dp(i) :第i个字符为结尾的字符串，最小分割次数

状态转移方程：

​ 第i个字符，是作为单独一个回文子串，还是作为上一个回文子串的一部分

​ dp(i) = j<i && [j+1,i] 是回文 min( dp(j) +1);

初始值:

​ 默认dp(i) 为最大值，即每单个字符一划分；

​ dp(i) = i-1;

返回值：

​ dp(s.length());

private boolean isTrue(String s,int star,int end){
    while(star<end){
        if(s.charAt(star++) != s.charAt(end--))
            return false;
    }
    return true;
}
public int minCut (String s) {
    int len = s.length();
    int[] dp = new int[len+1];
    for(int i = 0;i<=len;i++){
        dp[i] = i-1;
    }
    for(int i =1;i<=len;i++){
        for(int j = 0;j<i;j++){
            if(isTrue(s,j,i-1)){
                dp[i] = Math.min(dp[j]+1,dp[i]);
            }
        }
    }
    return dp[len];
}
上述方法两次循环时间复杂度是O(n^2),
判断回文串时间复杂度是O(n),
所以总时间复杂度为O(n^3)
对于过长的字符串，在OJ的时候会出现TLE(Time Limit Exceeded)

对回文字符串的优化也可以使用动规

状态：
子状态：从第一个字符到第二个字符是不是回文串，第1-3，第2-5，…
F(i,j): 字符区间 [i,j] 是否为回文串
状态递推：
F(i,j): true->{s[i]==s[j] && F(i+1,j-1)} OR false
上式表示如果字符区间首尾字符相同且在去掉区间首尾字符后字符区间仍为回文串，
则原字符区间为回文串
从递推公式中可以看到第i处需要用到第i+1处的信息，所以i应该从字符串末尾遍历
初始化：
F(i,j) = false
返回结果：
矩阵F(n,n), 只更新一半值（i <= j），n^2 / 2

private boolean[][] isTrue(String s){
    int len = s.length();
    boolean[][] ret = new boolean[len][len];
    for(int i = len-1;i >= 0;--i){
        for(int j = i;j<len;++j){
            if(j == i){
                //单字符为回文字符串
                ret[i][j] = true;
            }
            else if(j == i+1){
                //相邻字符如果相同，则为回文字符串
                if(s.charAt(i) == s.charAt(j)){
                    ret[i][j] = true;
                }else{
                    ret[i][j] = false;
                }
            }else{
                //f(i,j) = {s[i] == s[j] && f(i+1,j-1)}
                //j > i+1
                ret[i][j] = (s.charAt(i) == s.charAt(j) && ret[i+1][j-1]);
            }
        }
    }
    return ret;
}
上述方法判断回文串时间复杂度O(n^2)
主方法两次循环时间复杂度O(n^2)
总体时间复杂度O(n^2) ~ O(2 * n^2) = O(n^2) + O(n^2)
总结：
简单的动态规划问题，状态，状态递推和状态初始化都比较直观
对于复杂的动态规划问题，状态，状态递推和状态初始化都比较隐含，需要仔细推敲
尤其是状态递推可能需要额外的辅助判断条件才能达成

动态规划一点都不难！！！？