代码随想录算法训练营第47天|LeetCode 647. 回文子串、516.最长回文子序列

1. LeetCode 647. 回文子串

题目链接：https://leetcode.cn/problems/palindromic-substrings/description/
文章链接：https://programmercarl.com/0647.回文子串.html
视频链接：https://www.bilibili.com/video/BV17G4y1y7z9/

1.确定dp数组（dp table）以及下标的含义
布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。
注意：由于dp定义，则始终j>=i
2.确定递推公式
当s[i]与s[j]不相等，dp[i][j]一定是false。
当s[i]与s[j]相等时，有如下三种情况：

• 情况一：下标i 与 j相同，同一个字符例如a，当然是回文子串，即：dp[i][j] = true；
• 情况二：下标i 与 j相差为1，例如aa，也是回文子串，即：dp[i][j] = true；
• 情况三：下标i 与 j相差大于1的时，判断dp[i + 1][j - 1]是否为true。
• • 若为true，则是回文，即：dp[i][j] = true；
• • 若为false，则不是回文，即：dp[i][j] = false。

3.dp数组如何初始化
dp[i][j]初始化为false。
4.确定遍历顺序
从递推公式中可以看出，情况三是根据dp[i + 1][j - 1]是否为true，在对dp[i][j]进行赋值true的。
dp[i + 1][j - 1] 在 dp[i][j]的左下角，如图：

所以一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。
注意：由于dp定义，则始终j>=i
5.返回值
统计dp中true的个数。

解法：
class Solution {
    public int countSubstrings(String s) {
        //1.定义dp数组
        //dp[i][j]表示区间[i,j]范围的子字符串是否是回文子串。是,true;否,false
        boolean[][] dp = new boolean[s.length()][s.length()];
        //2.递推公式
        /**
        if (s.charAt(i) != s.charAt(j)) {
            dp[i][j] = false;
        } else {
            if ((j-i) == 0) {
                dp[i][j] = true;
            } else if ((j-i) == 1) {
                dp[i][j] = true;
            } else {
                if (dp[i+1][j-1] == true) {
                    dp[i][j] = true;
                }
            }
        }
         */
        //3.初始化
        //4.遍历顺序 从下往上，从左往右
        int res = 0;
        for (int i = s.length()-1;i>=0;i--) {
            for (int j = i;j<=s.length()-1;j++) {
                if (s.charAt(i) != s.charAt(j)) {
                    dp[i][j] = false;
                } else {
                    if ((j-i) == 0) {
                        dp[i][j] = true;
                        res++;
                    } else if ((j-i) == 1) {
                        dp[i][j] = true;
                        res++;
                    } else {
                        if (dp[i+1][j-1] == true) {
                            dp[i][j] = true;
                            res++;
                        }
                    }
                }
            }
        } 

        return res;
    }
}

2. LeetCode 516.最长回文子序列

题目链接：https://leetcode.cn/problems/longest-palindromic-subsequence/description/
文章链接：https://programmercarl.com/0516.最长回文子序列.html
视频链接：https://www.bilibili.com/video/BV1d8411K7W6/

思路：
1.确定dp数组（dp table）以及下标的含义
dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
2.确定递推公式
如果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]看看哪一个可以组成最长的回文子序列。
a.加入s[j]的回文子序列长度为dp[i + 1][j]。
b.加入s[i]的回文子序列长度为dp[i][j - 1]。
那么dp[i][j]一定是取最大的，即：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
3.dp数组如何初始化
当i与j相同，那么dp[i][j]一定是等于1的，即：一个字符的回文子序列长度就是1；
其他情况dp[i][j]初始为0。
4.确定遍历顺序
从递归公式中，可以看出，dp[i][j] 依赖于 dp[i + 1][j - 1] ，dp[i + 1][j] 和 dp[i][j - 1]，如图：

所以遍历i的时候一定要从下到上遍历，j从左向右遍历。
5.返回值
dp[0][s.length() - 1];

解法：
class Solution {
    public int longestPalindromeSubseq(String s) {
        
        //1.定义dp数组
        //dp[i][j]表示区间[i,j]内最长回文子序列的长度
        int[][] dp = new int[s.length()][s.length()];
        //2.递推公式
        /**
        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]);
        }
         */
        //3.初始化
        for (int i=0;i<s.length();i++) {
            dp[i][i] = 1;
        }
        //4.遍历顺序
        for (int i=s.length()-1;i>=0;i--) {
            for (int j=i+1;j<=s.length()-1;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];

    }
}