题目名称：最长回文子序列

题目描述

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

输入描述

输入为一行，字符串s。（长度不超过1000）

输出描述

输出一个整数，最长回文子序列的长度。

样例1

输入

bbba

输出

4

样例2

输入

cbbd

输出

2

AC代码

#include <iostream>
#include <iostream>
#include <string>
using namespace std;

int main() {
    string s;
    cin >> s;

    int n = s.length();
    int** dp = new int*[n];
    for (int i = 0; i < n; i++) {
        dp[i] = new int[n];
    }

    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }

    for (int i = n - 1; 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]);
            }
        }
    }
    
    
    cout << dp[0][n - 1] << endl;

    // 释放动态分配的内存
    for (int i = 0; i < n; i++) {
        delete[] dp[i];
    }
    delete[] dp;

    return 0;
}

首先，你的代码已经实现了找到最长回文子序列的功能，很不错！但是，这个问题确实有更高效的解法。

你的代码使用了动态规划的思想，通过填充一个二维数组dp来记录子问题的解。dp[i][j]表示字符串s从第i个字符到第j个字符之间的最长回文子序列的长度。

在你的代码中，你使用了一个双重循环来填充dp数组。这种方法的时间复杂度为O(n^2)，其中n是字符串s的长度。虽然这种方法已经是一个很好的解法，但是我们可以进一步优化。

我们可以使用另一种动态规划的思路，将问题转化为求解最长公共子序列（Longest Common Subsequence，简称LCS）的问题。具体做法是，将原字符串s反转得到字符串t，然后求解s和t的最长公共子序列的长度，即为最长回文子序列的长度。

这种方法的时间复杂度为O(n^2)，与你的方法相同，但是它的空间复杂度可以优化到O(n)。因为在求解最长公共子序列时，我们只需要使用一个一维数组来记录中间结果即可。

下面是使用最长公共子序列方法的代码示例：

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int longestPalindromeSubseq(string s) {
    string t = s;
    reverse(t.begin(), t.end());

    int n = s.length();
    int* dp = new int[n + 1];
    for (int i = 0; i <= n; i++) {
        dp[i] = 0;
    }

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

    int result = dp[n];

    delete[] dp;

    return result;
}

int main() {
    string s;
    cin >> s;

    int result = longestPalindromeSubseq(s);
    cout << result << endl;

    return 0;
}

这段代码中，我们使用了一个一维数组dp来记录中间结果。dp[i]表示字符串s的前i个字符和字符串t的前i个字符之间的最长公共子序列的长度。通过动态规划的思想，我们可以逐步填充dp数组，最终得到最长公共子序列的长度，即为最长回文子序列的长度。