516）最长回文子序列

https://leetcode-cn.com/problems/longest-palindromic-subsequence/
dp动态规划

回文子序列：
字符串中能构成回文的字符串，不同于字串，可以在顺序不变的情况下将元素提取出来使能构成回文，即我们可以删除某些字符来让某部分字串处于回文
题目：
给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。
例如

输入
“bbbab”
输出：
4
一个可能的最长回文子序列为 “bbbb”。

输入:
“cbbd”
输出:
2
一个可能的最长回文子序列为 “bb”。
提示:
1 <= s.length <= 1000
s 只包含小写英文字母

分析：什么是回文，回文子串，最长回文子串，最长回文子序列

回文： 正反顺序相同 如： qwerewq

回文子串： 字符串中的可以构成回文的子串
如:s=“wifhcvcndhhd” 其中 “cvc”,“dhhd”,"hh"是s的子串并且能构成回文。ps：单独一个字母和相同（hh）两个字母也算。

最长回文子串：当然就是回文子串中最长的部分了

最长回文子序列： 字符串中能构成回文的字符串，不同于子串，子序列可以在顺序不变的情况下将元素提取出来使能构成回文，即我们可以删除某些字符来让某部分字串处于回文。例如“bbbab”的回文子串为“bbb”，但是子序列不同，我们顺序不变的提取出“bbbb”，排除掉“a”，这样构成的子序列为“bbbb”。

刚开始想的是递归，但是不行递归会超内存。
参考了其他人的思路，主要有两种方法：
解1：
动态规划：
观察问题
当一个字符串第i个字符到第j个字符是回文时，那么i+1到j-1之间也一定是回文。
设
dp[i,j]=1 表示字符串从i到j之间的字符串构成回文。
当 dp[i]=dp[j] 时
有dp[i+1]=dp[j-1]

dp[i][i]=1 初始化1 单个字符的最长回文序列为1

如果s的第i个字符和第j个字符相同：
dp[i][j]=dp[i+1][j-1]+2;

如果s的第i个字符和第j个字符不同：
dp[i][j]=max(dp[i+1][j],dp[i][j-1])

class Solution {
public:

    int longestPalindromeSubseq(string s) {
       int n=s.length();
       int dp[n];
       int i,j,tmp,max;
       for(j=0;j<n;j++)//将二维数组转化为了两个一维数组
       {
           max=0;
           dp[j]=1;
           for(i=j-1;i>=0;i--)
           {
               tmp=dp[i];
               if(s[i]==s[j])
               {
                   dp[i]=max+2;
               }
               max=tmp>max?tmp:max;
           }
           
       }
        
            max=0;
           for(i=0;i<n;i++){
               max=max>dp[i]?max:dp[i];
           }
           return max;      

    }
    
};

解法2：转化为求最长公共子序列

求字符串本身和他的逆序的最长公共子序列

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n=s.size();
        string s1=s,s2;  
        reverse(s.begin(),s.end());
        s2=s;
        vector<vector<int>> dp(n+1,vector<int>(n+1));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;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][n];

    }
};