LeetCode刷题系列 -- 516. 最长回文子序列

在河之洲木水

已于 2022-12-04 01:00:57 修改

阅读量393

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode 文章标签： leetcode 算法职场和发展

于 2022-06-20 00:17:10 首次发布

本文链接：https://blog.csdn.net/qq_33775774/article/details/125364688

LeetCode 专栏收录该内容

246 篇文章

订阅专栏

本文介绍了如何使用动态规划解决寻找字符串中最长回文子序列的问题。通过初始化dp数组并按照从内向外的顺序遍历，确定状态转移方程，最终找到最长回文子序列的长度。示例代码分别给出了Java和C++的实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

示例 1：

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

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。

提示：

1 <= s.length <= 1000
s 仅由小写英文字母组成

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

思路：最优子结构原理和 dp 数组遍历方向 :: labuladong的算法小抄

动态规划
1. 定义二维数组 dp[s.length][s.length] ，dp[i][j] 表示 s[i,...,j] 子序列的最长回文子序列
2. 初始化base，dp[i][i] = 1, i >= 0 && i < s.length, 最短的子序列长度就是单个字符本身，长度为 1
3. 若是 s[i] == s[j] ，则 dp[i][j] = dp[i+1][j-1] + 2;
   若是 s[i] != s[j], 则 dp[i][j] = max(dp[i][j-1],dp[i+1][j])
注：遍历的顺序

1、遍历的过程中，所需的状态必须是已经计算出来的。

2、遍历结束后，存储结果的那个位置必须已经被计算出来。

本题目中看状态转移方程，计算 dp[ i ][ j ] 时，需要先知道 dp[i+1][j-1] 、dp[i][j-1] 与 dp[i+1][ j ] 。所以遍历的时候应该从内向外一点一点的展开。

即：

1. for(int j=1;j < n;j++) {

for(int i=j-1;i>=0;i--) {

// do something

}

}

2. for(int i=n-2;i>=0;i--) {

for(int j=i+1;j<n;j++) {

// do something

}

}

java代码：

class Solution {
  public int longestPalindromeSubseq(String s) {
        int[][] dp = new int[s.length()][s.length()];

        // 1. 初始化 base
        for (int i = 0; i < s.length(); i++) {
            dp[i][i] = 1;
            if (i < s.length() - 1) {
                if (s.charAt(i) == s.charAt(i + 1)) {
                    dp[i][i + 1] = 2;
                } else {
                    dp[i][i + 1] = 1;
                }
            }
        }

        // 2. 更新 dp
        for (int i = s.length()-3; i >=0; i--) {
            for (int j = i + 2; 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];
    }
}

c++

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        
        // 定义二维数组 dp ，dp[i][j] 表示 s[i,...,j] 最长回文回文子序列长度
        vector<vector<int>>  dp(n,vector<int>(n));

        // 初始化
        for(int i=0;i<n;i++) {
            dp[i][i] = 1; // 任意一个字符都是长度为 1 的回文子序列
        }

       
        // 状态转移, j<n
        // for(int i=n-2;i>=0;i--) {
        //     for(int j=i+1;j<n;j++) {
        //         if(s[i] == s[j]) {
        //             dp[i][j] = dp[i+1][j-1] + 2;
        //         } else {
        //             dp[i][j] = max(dp[i+1][j],dp[i][j-1]);
        //         }
        //     }
        // }

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

        return dp[0][n-1];

    }
};