134、LeetCode-516.最长回文子序列

题目：

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/longest-palindromic-subsequence

思路：

回文串的判断，都是每次拿两个字符进行操作！

回文子序列和回文子串不同，子串时不可改变顺序和组成；但是子序列可以将子串中的字符进行删除处理！存在更多的可能性

但是更改的操作只有删除！也更加容易分析

1）动态规划：dp数组代表i开头，j结尾时的最长回文子序列

当字符相同时，只用拿到i + 1和j - 1时的最长子序列加2即可；

不同时，需要拿到分别删除一个字符时的更大值，即i+1或者j-1时的更大值！

2）将字符串反转 + 求两个字符串的最长公共子序列

java中，反转字符串需要使用StringBuilder，不能使用String

代码：

1）动态规划：自己写的有点繁琐，但是思路清晰

class Solution {
    public int longestPalindromeSubseq(String s) {
        //与回文子串不同
        int len = s.length();
        int[][] dp = new int[len][len];

        for(int i = len - 1;i >= 0 ;i--){
            for(int j = i;j < len;j++){
                if(s.charAt(i) == s.charAt(j) &&  j - i < 3){//遇见相同，长度1-3，都必然是回文串
                    dp[i][j] = j - i + 1;
                }
                else if(s.charAt(i) == s.charAt(j) && j - i >= 3){
                    dp[i][j] = dp[i + 1][j- 1] + 2;
                }
                else if(s.charAt(i) != s.charAt(j)){
                    //此时两个字符不相同时，需要删除其中一个字符，继续找最大的：i + 1删除头；j - 1删除尾
                    dp[i][j] = Math.max(dp[i + 1][j],dp[i][j - 1]);//直接替换最大值
                }
            }
        }
        return dp[0][len - 1];
    }
}

 可以根据状态转移方程，进行性能优化！将对角线上的内容初始化，就可以将相同时的判断简化！

class Solution {
    public int longestPalindromeSubseq(String s) {
        //与回文子串不同
        int len = s.length();
        int[][] dp = new int[len][len];

        for(int i = len - 1;i >= 0 ;i--){
            //初始化对角线
            dp[i][i] = 1;
            for(int j = i + 1;j < len;j++){
                if(s.charAt(i) == s.charAt(j)){//遇见相同，长度1-3，都必然是回文串
                    dp[i][j] = dp[i + 1][j- 1] + 2;
                }
                else if(s.charAt(i) != s.charAt(j)){
                    //此时两个字符不相同时，需要删除其中一个字符，继续找最大的：i + 1删除头；j - 1删除尾
                    dp[i][j] = Math.max(dp[i + 1][j],dp[i][j - 1]);//直接替换最大值
                }
            }
        }
        return dp[0][len - 1];
    }
}

2)转换成求最长公共子序列的问题：先将字符串反转

class Solution {
    public int longestPalindromeSubseq(String s) {
        //与回文子串不同
        StringBuilder s2 = new StringBuilder(s);//将字符串反转
        StringBuilder s1 = s2.reverse();
        //然后找公共最长子序列即可
        int len = s.length();
        int[][] dp = new int[len + 1][len + 1];
        for(int i = 1;i <= len;i++){
            for(int j = 1;j <= len;j++){
                if(s.charAt(i - 1) == s1.charAt(j - 1)){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                else{
                    dp[i][j] = Math.max(dp[i - 1][j],dp[i][j - 1]);
                }
            }
        }
        return dp[len][len];
    }
}