代码随想录算法训练营day57 | 647. 回文子串，516.最长回文子序列，动态规划总结篇-CSDN博客

本文链接：https://blog.csdn.net/2301_77450803/article/details/130961185

代码随想录算法训练营day57 | 647. 回文子串，516.最长回文子序列，动态规划总结篇

647. 回文子串
- 解法一：动态规划
- 解法二：双指针中心扩散法
516.最长回文子序列
- 解法一：动态规划
动态规划总结篇

647. 回文子串

教程视频：https://www.bilibili.com/video/BV17G4y1y7z9
在这里插入图片描述

解法一：动态规划

class Solution {
    public int countSubstrings(String s) {
        // 1、dp[i][j]含义：字符串[i, j]是否为回文子串
        // 2、递归公式：dp[i][j]=dp[i+1][j-1];
        // 3、dp初始化：为了不影响递归中的判断，所有下标均初始化为false
        // 4、遍历顺序：当前状态是由左下角状态推导出来的，外层for倒序遍历，内层for正序遍历
        // 5、打印验证。
        boolean[][] dp = new boolean[s.length()][s.length()];
        int result=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){
                        dp[i][j]=true;
                        result++;
                    }else{
                        dp[i][j]=dp[i+1][j-1];
                        if(dp[i][j])result++;
                    }
                }
            }
        }
        return result;
    }
}

解法二：双指针中心扩散法

遍历数组，假定每个数组为中心元素，统计回文子串。
在遍历中心点的时候，要注意中心点有两种情况。一个元素可以作为中心点，两个元素也可以作为中心点。

class Solution {
    public int countSubstrings(String s) {
        int result=0;
        for(int i=0;i<s.length();i++){
            result+=extend(s, i, i);//一个元素作为中心点
            result+=extend(s, i, i+1);//两个元素作为中心点
        }
        return result;
    }
	// 中心扩散判断回文串
    public int extend(String s, int left, int right){
        int result = 0;
        while(left>=0 && right<s.length()){
            if(s.charAt(left)==s.charAt(right)){
                result++;
            }else{
                break;// 不相等就不能再构成回文串
            }
            left--;
            right++;
        }
        return result;
    }
}

516.最长回文子序列

教程视频：https://www.bilibili.com/video/BV1d8411K7W6
在这里插入图片描述

解法一：动态规划

在这里插入图片描述
右侧初始化一条对角线代码：(利用了数组默认值为0)

class Solution {
    public int longestPalindromeSubseq(String s) {
        // 1、dp[i][j]含义：字符串[i, j]中最长回文子串长度
        // 2、递归公式：从两侧向中间依次判断
        // 3、dp初始化：指向单个字符时，长度为1，dp[i][i]=1;
        // 4、遍历顺序：当前状态是由左下角状态推导出来的，外层for倒序遍历，内层for正序遍历
        // 5、打印验证。
        int[][] dp = new int[s.length()+1][s.length()+1];

        for(int i=s.length()-1;i>=0;i--){
            dp[i][i]=1;//初始化
            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][j], Math.max(dp[i+1][j], dp[i][j-1]));
                }
            }
        }
        return dp[0][s.length()-1];
    }
}

左侧初始化两条对角线代码：

class Solution {
    public int longestPalindromeSubseq(String s) {
        // 1、dp[i][j]含义：字符串[i, j]中最长回文子串长度
        // 2、递归公式：从两侧向中间依次判断，两侧相等时dp[i][j]=dp[i+1][j-1]+2;，两侧不等时dp[i][j]=Math.max(dp[i+1][j], dp[i][j-1]);
        // 3、dp初始化：
        /* 
           if(s.charAt(i)==s.charAt(j)){
        	    if(j-i<=1){dp[i][j]=j-i+1;}
           }else{
           		dp[i][j]=Math.max(dp[i+1][j], dp[i][j-1]);
           }
       	*/
        // 4、遍历顺序：当前状态是由左下角状态推导出来的，外层for倒序遍历，内层for正序遍历
        // 5、打印验证。
        int[][] dp = new int[s.length()][s.length()];
        int result = 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){//如果遍历到中心则直接赋值（初始化）
                        dp[i][j]=j-i+1;
                    }else{//否则累计回文子串长度
                        dp[i][j]=dp[i+1][j-1]+2;
                    }
                }else{//外层两个字符不相等
                    //比较删左侧和删右侧哪个子串长度更长，取更长的值（部分初始化）
                    dp[i][j]=Math.max(dp[i+1][j], dp[i][j-1]);
                }
                result=Math.max(dp[i][j],result);
            }
        }
        return result;
    }
}