动态规划——最长回文子序列

问题来源：leetcode 516。

问题定义

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

示例 1:

输入:

"bbbab"
输出:

4
一个可能的最长回文子序列为 "bbbb"。

示例 2:

输入:

"cbbd"
输出:

2
一个可能的最长回文子序列为 "bb"。

提示：

• 1 <= s.length <= 1000
• s 只包含小写英文字母

转换成最长公共子序列问题

最长公共子序列。

首先将字符串反转，然后求这两个字符串的最长公共子序列便是该字符串的最长回文子序列。

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        string s_reverse = s;
        reverse(s_reverse.begin(), s_reverse.end());
        return lcss(s, s_reverse);
    }

    int lcss(string& s1, string& s2) {
        int n = s1.size(), m = s2.size();
        vector<vector<int>> dp(n+1, vector<int>(m+1));
        for(int i=1; i<=n; i++) {
            for(int j=1; j<=m; j++) {
                if(s1[i-1] == s2[j-1]) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
                }
            }
        }
        return dp[n][m];
    }
};

直接动态规划分析

优化子结构：设原问题的字符串 $S=s_1{s}_2,...s_n$ 的最长回文子序列为 $X=x_1,x_2,...,x_m$：

• 如果 $s_1=s_n$，那么 $X^{{}^{\prime }}=x_2,...x_{n-1}$ 是子问题的字符串 $S^{{}^{\prime }}=s_2,...,s_{n-1}$ 的最长回文子序列，即需要求解子问题 $S^{{}^{\prime }}$ 的最优解 $X^{{}^{\prime }}$。反证法证明：如果 $X^{{}^{\prime }}$ 不是 $S^{{}^{\prime }}$ 的最优解，那么 $S^{{}^{\prime }}$ 存在一个更长的回文子序列，在此基础上再加上 $s_1$ 和 $s_n$，可以得到 $S$ 的一个更长的回文子序列，与 $X$ 是 $S$ 的一个最长的回文子序列矛盾。
• 如果 $s_1\ne s_n$，那么 $X$ 是子问题 $S_1^{{}^{\prime }}=s_1,...,s_{n-1}$ 和 $S_2^{{}^{\prime }}=s_2,...,s_n$ 的最长回文子序列中较长的那个，即需要求解子问题 $S_1^{{}^{\prime }}$ 和 $S_2^{{}^{\prime }}$ 的最优解，同样可以通过反证法来证明。

重叠子问题：简单地通过递归算法来计算，会有子问题被重复计算。

递归地定义最优解的值：设 $dp(i,j)$ 表示以 $s_i$ 开头，以 $s_j$ 结尾的字符串的最长回文子序列的长度，那么：

• 如果 $i>j$，那么 $dp(i,j)=0$；
• 如果 $i=j$，那么 $dp(i,j)=1$;
• 如果 $i<j$，那么：
  • 如果 $s_i=s_j$，则 $dp(i,j)=2+dp(i+1,j-1)$；
  • 否则， d p ( i , j ) = m a x {   d p ( i + 1 , j ) ,   d p ( i , j − 1 )   } dp(i,j) = max\{\ dp(i+1, j),\ dp(i, j-1)\ \} dp(i,j)=max{ dp(i+1,j), dp(i,j−1) }

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        vector<vector<int>> dp(n, vector<int>(n));
        for(int i=0; i<n; i++) {
            dp[i][i] = 1;
        }
        for(int l = 2; l<=n; l++) {
            for(int i = 0; i<= n-l; i++) {
                int j = i + l - 1;
                if(s[i] == s[j]) {
                    dp[i][j] = 2 + dp[i+1][j-1];
                } else {
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1]);
                }
            }
        }
        return dp[0][n-1];
    }
};