dp(六) 线性dp整合 最长（公共子串、公共子序列、上升子序列、回文子串）

 1、最大公共子串_牛客题霸_牛客网​编辑

 2、最长上升子序列(一)_牛客题霸_牛客网

 3、最长回文子串_牛客题霸_牛客网

 4、最长公共子序列(二)_牛客题霸_牛客网

---

#include <iostream>
using namespace std;
#include<vector>
 
int main() 
{
    string str1,str2;
    cin>>str1;
    // 截取划分str1和str2
    int pos = str1.find(',');
    str2 = str1.substr(pos+1);
    str1 = str1.substr(0, pos);
    
    int max = 0;// 记录最长长度
    vector<int> dp(str1.size()+1, 0);
    for(int i = 1; i <= str1.size(); i++)
    {
        // 滚动数组 且需要不断使用之前的值，所以从后往前更新
        for(int j = str2.size(); j >= 1; j--)
        {
            // ij都从1开始所以str1和str2访问i j都要-1操作
            if(str1[i-1] == str2[j-1])
            dp[j] = dp[j-1]+1;// 相等长度加一
            else
            dp[j] = 0;        // 不相等该次即为0
            if(dp[j] > max)
            max = dp[j];        // 不断维护最大值
        }
    }
    cout<<max<<endl;
    return 0;
}
// 64 位输出请用 printf("%lld")

2、最长上升子序列(一)_牛客题霸_牛客网

状态定义 F(i) 表示前i结点的上升子序列的最大长度

状态转移：F(i) = max(F(i), F(j) + arr[i]>arr[j] ? 1 : 0);

初始状态：dp(arr.size(), 1)；

返回 max标记的最大值；

心得：慢慢的推导这个状态转移方程就是通过一个个自己通过例子得来的结果中发现规律的。

class Solution {
public:
    int LIS(vector<int>& arr) {
        // write code here
        if(arr.size()==0)
        return 0;
        vector<int> dp(arr.size(), 1);
        int _max = 1;// 记录最大值
        for(int i = 1; i < arr.size(); i++)
        {
            for(int j = 0; j < i; j++)
            {
                if(arr[i] > arr[j])
                    dp[i] = max(dp[i], dp[j]+1);
                if(dp[i] > _max)
                    _max = dp[i]; // 更新最大值
            }
        }
        return _max;
    }
};

 3、最长回文子串_牛客题霸_牛客网

回文分割的写过下面这个更难的最小的回文串分割次数，这道题写起来都不算啥了。

具体下面的解法与时间复杂度的优化可以看下方博客链接，非常详细的演示。http://t.csdn.cn/k22JShttp://t.csdn.cn/k22JS

 【解法一】利用动态规划 较为基础的线性dp

class Solution {
public:
    bool IsPal(int j, int i, string s)
    {
        while(j<i)
        {
            if(s[j++] != s[i--])
            return false;
        }
        return true;
    }
    int getLongestPalindrome(string A) {
        // write code here
        vector<int> dp(A.size(), 1);
        int _max = 1;
        for(int i = 1; i < A.size(); i++)
        {
            for(int j = 0; j <= i; j++)
            {
                // 如果【j, i】为回文串
                if(IsPal(j, i, A))
                {
                    int len = i-j+1;
                    dp[i] = max(dp[i], len);
                    if(dp[i] > _max)_max = dp[i];
                }
            }
        }
        return _max;
    }
};

【解法二】优化一下时间复杂度

解法一的时间复杂度为O(n^3)可以将回文串的判断这里做一个优化，将判断回文串优化为O(1)时间复杂度。将之前的O(n^3)->O(n^2)

class Solution {
public:
    vector<vector<bool>> GetMat(string s)
    {
        int len = s.size();
        vector<vector<bool>> Mat(len, vector<bool> (len, false));
        for(int i = len-1; i >= 0; i--)
        {
            for(int j = i; j <= len-1; j++)
            {
                if(i == j) Mat[i][j] = true;  // 为同一个元素
                else if(i+1 == j) Mat[i][j] = (s[i]==s[j]);  //  为相邻的俩个元素
                else Mat[i][j] = (s[i]==s[j])&&Mat[i+1][j-1];//  俩边相同的条件下，
                                                             //  内部也相同，才为真。
            }
        }
        return Mat;
    }

    int getLongestPalindrome(string A) {
        // write code here
        vector<int> dp(A.size(), 1);
        int _max = 1;
        vector<vector<bool>> Mat = GetMat(A);
        for(int i = 0; i < A.size(); i++)
        {
            for(int j = 0; j <= i; j++)
            {
                // 如果【j, i】为回文串
                if(Mat[j][i])
                {
                    int len = i-j+1;
                    dp[i] = max(dp[i], len);
                    if(dp[i] > _max)_max = dp[i];
                }
            }
        }
        return _max;
    }
};

 4、最长公共子序列(二)_牛客题霸_牛客网

【题解一】当成返回的是最长连续子序列了。。

class Solution {
public:
    string LCS(string s1, string s2) {
        // write code here
        if(s1.empty()||s2.empty())
        return string("-1");
        int max = 0;
        int pos = 0;
        vector<vector<int>> dp(s1.size()+1, vector<int> (s2.size()+1, 0));
        for(int i = 1; i <= s1.size(); i++)
        {
            for(int j = s2.size(); j >= 1; j--)
            {
                if(s1[i-1] == s2[j-1])
                    dp[i][j] = dp[i-1][j-1]+1;
                else dp[i][j] = 0;
                if(dp[i][j] > max)
                {
                    max = dp[i][j];
                    pos = i-1;
                }
            }
        }
        if(max==0) return string("-1");
        return string(s1.substr(pos-max+1, max));
    }
};

【正解】

 状态：F(i, j) 表示s1的前i个字符与s2的前j个字符最长公共子序列

状态转移  F(i, j)  = F(i-1, j-1)+1

                             max(F(i-1, j）,F(i, j-1))

初始状态全为0；

当把dp数组初始化好了之后，从右下角开始，找上图中框框位置的元素，满足长度每次第一次发生变化的i下标对应的s1元素入栈。

class Solution {
public:
    string LCS(string s1, string s2) {
        // write code here
        if(s1.empty()||s2.empty())
        return string("-1");
        string res;
        vector<vector<int>> dp(s1.size()+1, vector<int> (s2.size()+1, 0));
        for(int i = 1; i <= s1.size(); i++)
        {
            for(int j = 1; j <= s2.size(); j++)
            {
                if(s1[i-1] == s2[j-1])
                    dp[i][j] = dp[i-1][j-1]+1;
                else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
        stack<char> s;
        int i = s1.size();
        int j = s2.size();
        while(i>=1 && j>=1)
        {
            if(dp[i][j] == dp[i][j-1])
                j--;
            else if(dp[i][j] == dp[i-1][j])
                i--;
            else if(dp[i][j] > dp[i-1][j-1])
            {
                i--;
                j--;
                s.push(s1[i]);
            }
        }
        while(!s.empty())
        {
            res += s.top();
            s.pop();
        }
        return res == "" ? "-1" : res;
    }
};