516. 最长回文子序列

题目来源

516. 最长回文子序列

题目分析

给定一个字符串 s，找到其中最长的回文子序列，并返回该序列的长度。假设序列的长度不超过 1000。

题目难度

• 难度：中等

题目标签

• 标签：动态规划, 数组

题目限制

• 1 <= s.length <= 1000

解题思路

思路1：动态规划

1. 问题定义：

   • 定义 dp[i][j] 表示字符串 s 从第 i 个字符到第 j 个字符的最长回文子序列的长度。

2. 状态转移：

   • 当 s[i] == s[j] 时，dp[i][j] = dp[i + 1][j - 1] + 2，即如果两端字符相同，则可以加上这两个字符长度，转化为剩余子序列的最长回文子序列。
   • 当 s[i] != s[j] 时，dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])，即如果两端字符不相同，则取去掉 s[i] 或 s[j] 后的最长回文子序列的最大值。

3. 初始化：

   • 对于所有的 i，dp[i][i] = 1，即单个字符的最长回文子序列长度为 1。

4. 最终结果：

   • 返回 dp[0][n - 1]，即整个字符串的最长回文子序列长度。

核心算法步骤

1. 动态规划：
   • 初始化 dp 二维数组，表示不同子序列的状态。
   • 通过双重循环从后往前遍历字符串，逐步更新 dp 数组中的值。
   • 最终返回 dp[0][n - 1]。

代码实现

以下是求解最长回文子序列的 Java 代码：

/**
 * 516. 最长回文子序列
 * @param s 字符串
 * @return 最长回文子序列的长度
 */
public int longestPalindromeSubseq(String s) {
    char[] chars = s.toCharArray();
    int n = chars.length;
    int[][] dp = new int[n][n];
    
    // 初始化: 单个字符的最长回文子序列长度为1
    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }
    
    // 填充dp数组，从后向前遍历
    for (int i = n - 1; i >= 0; i--) {
        for (int j = i + 1; j < n; j++) {
            if (chars[i] == chars[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][n - 1];
}

代码解读

• dp[i][j] 表示字符串 s 从第 i 个字符到第 j 个字符的最长回文子序列的长度。
• chars[i] == chars[j] 时，最长回文子序列的长度在原基础上加 2。
• chars[i] != chars[j] 时，取去掉两端字符后的最大回文子序列长度。

性能分析

• 时间复杂度：O(n^2)，其中 n 是字符串的长度，双重循环遍历 dp 数组。
• 空间复杂度：O(n^2)，需要 n*n 大小的 dp 数组来存储动态规划的状态值。

测试用例

你可以使用以下测试用例来验证代码的正确性：

String s1 = "bbbab";
int result1 = longestPalindromeSubseq(s1);
System.out.println(result1); // 输出: 4 ("bbbb")

String s2 = "cbbd";
int result2 = longestPalindromeSubseq(s2);
System.out.println(result2); // 输出: 2 ("bb")

String s3 = "a";
int result3 = longestPalindromeSubseq(s3);
System.out.println(result3); // 输出: 1

String s4 = "abcba";
int result4 = longestPalindromeSubseq(s4);
System.out.println(result4); // 输出: 5 ("abcba")

扩展讨论

优化写法

• 空间优化：可以将空间复杂度优化为 O(n)，通过仅保存当前行和上一行的状态来更新当前状态。

其他实现

• 可以使用递归+记忆化搜索来实现，不过在性能上不如动态规划高效。

总结

最长回文子序列问题通过动态规划方法解决，利用区间 dp 来表示不同子序列的状态，最终计算出字符串的最长回文子序列长度。通过合理的状态转移方程可以有效求解该问题。