Day60｜动态规划part17：647. 回文子串、516.最长回文子序列、动态规划总结篇

最新推荐文章于 2024-06-16 22:47:03 发布

QHG7C0

最新推荐文章于 2024-06-16 22:47:03 发布

阅读量721

点赞数 16

分类专栏：数据结构与算法（二刷）文章标签：动态规划算法

本文链接：https://blog.csdn.net/weixin_43303286/article/details/138465772

版权

数据结构与算法（二刷）专栏收录该内容

65 篇文章 0 订阅

订阅专栏

647. 回文子串

这题是求字符串中的回文子串数量。

动态规划解法

dp数组含义

本题如果我们定义，dp[i] 为下标i结尾的字符串有 dp[i]个回文串的话，我们会发现很难找到递归关系。

dp[i] 和 dp[i-1] ，dp[i + 1] 看上去都没啥关系。

此时我们是不是能找到一种递归关系，也就是判断一个子字符串（字符串的下表范围[i,j]）是否回文，依赖于，子字符串（下表范围[i + 1, j - 1]））是否是回文。

所以实际的含义：布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。

确定递推公式

就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。

当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。

当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况

情况一：下标i 与 j相同，同一个字符例如a，当然是回文子串
情况二：下标i 与 j相差为1，例如aa，也是回文子串
情况三：下标：i 与 j相差大于1的时候，例如cabac，此时s[i]与s[j]已经相同了，我们看i到j区间是不是回文子串就看aba是不是回文就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是回文就看dp[i + 1][j - 1]是否为true。

故递推公式为：

if (s[i] == s[j]) {
    if (j - i <= 1) { // 情况一 和 情况二
        result++;
        dp[i][j] = true;
    } else if (dp[i + 1][j - 1]) { // 情况三
        result++;
        dp[i][j] = true;
    }
}

最后记录的result就是回文子串数。

dp初始化

直接全都初始化为false。

确定遍历顺序

从下到上，从左到右遍历。（i是上下，j是左右，i从s.length开始，j从i开始）

举例推导dp数组

注意因为dp[i][j]的定义，所以j一定是大于等于i的，那么在填充dp[i][j]的时候一定是只填充右上半部分。

最终代码：

class Solution {
        public int countSubstrings(String s) {
            boolean dp[][] = new boolean[s.length()][s.length()];
            int res = 0;

            for(int i = s.length() - 1; i >= 0; i--){
                for(int j = i; j < s.length(); j++){
                    if(s.charAt(i) == s.charAt(j)){
                        if(j - i <= 1){
                            res++;
                            dp[i][j] = true;
                        }else if(dp[i + 1][j - 1]){
                            res++;
                            dp[i][j] = true;
                        }
                    }
                }
            }


            return res;


        }
    }

其他解法

不用dp，不知道这是啥解法，有空研究一下

class Solution {
        public int countSubstrings(String s) {
            int n = s.length();
            int ans = 0;
            for (int i = 0; i < 2 * n - 1; i++) {
                int l = i / 2, r = i / 2 + i % 2;
                while (l >= 0 && r < n && s.charAt(l) == s.charAt(r)) {
                    l--;
                    r++;
                    ans++;
                }
            }
            return ans;
        }
    }

516. 最长回文子序列

回文子串是要连续的，回文子序列可不是连续的！

确定dp数组及其含义

dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。

递推公式

在判断回文子串的题目中，关键逻辑就是看s[i]与s[j]是否相同。

如果s[i]与s[j]相同，那么dp[i][j] = dp[i + 1][j - 1] + 2;

如果s[i]与s[j]不相同，说明s[i]和s[j]的同时加入并不能增加[i,j]区间回文子序列的长度，那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。

加入s[j]的回文子序列长度为dp[i + 1][j]。

加入s[i]的回文子序列长度为dp[i][j - 1]。

dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);

初始化

当i与j相同，那么dp[i][j]一定是等于1的，即：一个字符的回文子序列长度就是1。其他就是0；

确定遍历顺序

从下到上遍历，从左往右遍历。

举例推导dp数组

最终代码：

class Solution {
    public int longestPalindromeSubseq(String s) {
        int[][] dp = new int[s.length()][s.length()];
        for(int i = 0; i < s.length(); i++){
            dp[i][i] = 1;
        }

        for(int i = s.length() - 1; i >= 0; i--){
            for(int j = i + 1; j < s.length(); j++){
                if(s.charAt(i) == s.charAt(j)){
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }else {
                    dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[0][s.length() - 1];
    }
}