【动态规划 - 最长回文子串】｜Java 刷题打卡

 

“_(:з」∠)_吾虽浪迹天涯，却未迷之本心

刷题之路，任重而道远啊

什么题可以选择动态规划来做？

1.计数

• 有多少种方式走到右下角
• 有多少种方法选出k个数是的和是sum

2.求最大值最小值

• 从左上角走到右下角路径的最大数字和
• 最长上升子序列长度

3.求存在性

• 取石子游戏,先手是否必胜
• 能不能选出k个数使得和是sum

题目一

leecode 5. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：输入: "babad"

输出: "bab" 注意: "aba" 也是一个有效答案。

示例 2：输入: "cbbd"

输出: "bb"

看了之前的文章，我们就四步走吧

1.1. 动态规划组成部分1：确定状态

简单的说，解动态规划的时候需要开一个数组，数组的每个元素f[i]或者f[i][j]代表什么，类似数学题中x, y, z代表什么

在这道题中，我们定义f[i][j] 表示字符串 s 的第 i 到 j 个字母组成的串是否为回文串

解动态规划需要两个意识：

• 最后一步
• 子问题

最后一步

我们用示例一来讲解，下图是第一步和第二步的判断过程，很明显最后一步为下标为4的字母b与前面所有元素进行比较，得出最长的回文子串。

子问题

我们可以看到如果f[i] =f[j]，要判定它是一个回文串，需要判定

f[i]j] = f[i+1]f[j-1] ： 从i到j是一个回文串，那么从i+1到j-1一定也是一个回文串

也就是如上图需要判定a=a

**1.2. 动态规划组成部分2：**转移方程

对于从i到j长度的字符串，判定它是一个回文串：

f[i]j] = f[i+1]f[j-1]

同时我们也知道，f[i+1][j-1]这是一个已知的，因为最后一步的上一步已经将结果保存,也就是f[i+1][j-1] = f[i+2]f[j-2]

**1.3. 动态规划组成部分3：**初始条件和边界情况

当剩余判定字母个数<3 并且 f[i] = f[j]，它一定是回文串。

对于字母本身来说f[i][i],从i到i的字符串，它也是回文。

**1.4. 动态规划组成部分4：**计算顺序

如上图，我们用j去匹配0~i (i < j)

它的时间复杂度是On^2,由于是二维数据空间复杂度也是On^2

当然也有其他的解决办法如中心扩散和马拉车。

参考代码

// 动态规划
public String longestPalindrome(String s) {
    // 特判
    int len = s.length();
    if (len < 2) {
        return s;
    }

    int maxLen = 1;
    int begin = 0;

    // dp[i][j] 表示 s[i, j] 是否是回文串
    boolean[][] dp = new boolean[len][len];
    char[] charArray = s.toCharArray();

    for (int i = 0; i < len; i++) {
        dp[i][i] = true; // 对本身来说就是回文
    }
    for (int j = 1; j < len; j++) {
        for (int i = 0; i < j; i++) {
            if (charArray[i] != charArray[j]) {
                dp[i][j] = false;
            } else {
                if (j - i < 3) {
                    dp[i][j] = true;
                } else {
                    dp[i][j] = dp[i + 1][j - 1]; // 要满足这个条件，必需先满足j - i > 3考虑边界
                }
            }

            // 只要 dp[i][j] == true 成立，就表示子串 s[i..j] 是回文，此时记录回文长度和起始位置
            if (dp[i][j] && j - i + 1 > maxLen) {
                maxLen = j - i + 1;
                begin = i;
            }
        }
    }
    return s.substring(begin, begin + maxLen);
}

@Test
public void islongestPalindrome() {
    String i = longestPalindrome("babaxaxab");
    Assert.assertNotNull(i);
}
复制代码

简单的看一下中心扩散的代码

参考代码

/***********************做第5题前先做 125. 验证回文串 （双指针+原字符判断）**********************/
public boolean isPalindrome(String s) {
    int n = s.length();
    int left = 0, right = n - 1;
    while (left < right) {
        //判断输入的是否全是英文或数字,不能判断中文
        while (left < right && !Character.isLetterOrDigit(s.charAt(left))) { 
            ++left; // 遇到不是数字或字母的就移动一位
        }
        while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
            --right;
        }
        if (left < right) {
            // 判断是否相等
            if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) { 
                return false;
            }
            ++left;
            --right;
        }
    }
    return true;
}
 @Test
public void isisPalindrome125() {
    boolean i = isPalindrome("a;bb,a");
    Assert.assertNotNull(i);
}
复制代码

参考代码

// 中心扩散
public String longestPalindromeMid(String s) {
    int len = s.length();
    if (len < 2) {
        return s;
    }
    // 初始长度为 1
    int maxLen = 1;
    String res = s.substring(0, 1);
    // 中心位置枚举到 len - 2 即可
    for (int i = 0; i < len - 1; i++) {
        String oddStr = centerSpread(s, i, i); // 奇数
        String evenStr = centerSpread(s, i, i + 1);// 偶数
        String maxLenStr = oddStr.length() > evenStr.length() ? oddStr : evenStr;
        if (maxLenStr.length() > maxLen) {
            maxLen = maxLenStr.length();
            res = maxLenStr;
        }
    }
    return res;
}

private String centerSpread(String s, int left, int right) {
    // left = right 的时候，此时回文中心是一个字符，回文串的长度是奇数
    // right = left + 1 的时候，此时回文中心是一个空隙，回文串的长度是偶数
    int len = s.length();
    int i = left;
    int j = right;
    while (i >= 0 && j < len) {
        if (s.charAt(i) == s.charAt(j)) {
            i--;
            j++;
        } else {
            break;
        }
    }
    // 这里要小心，跳出 while 循环时，恰好满足 s.charAt(i) != s.charAt(j)，因此不能取 i，不能取 j
    return s.substring(i + 1, j);
}
@Test
public void islongestPalindromeMid() {
    String i = longestPalindromeMid("babad");
    Assert.assertNotNull(i);
}
复制代码