最长公共子序列，最长公共子串，最长上升序列 动态规划

最长公共子序列，最长公共子串，最长上升序列 动态规划

1.力扣1143 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
若这两个字符串没有公共子序列，则返回 0。
示例：
输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace”，它的长度为 3。

解题思路
暴力解法：可以通过枚举两个字符串str1,str2的全部非空子序列，然后依次比较得出结果。一个长度为n的字符串的非空子序列共有2ⁿ-1种（每个位置的字符要么在子串要么不在，排除所有字符都不在序列中的情况，共有2ⁿ-1种），设str1.length=n，str2.length=m，则比较两个字符串的全部子序列需要用一个双重循环，时间复杂度为O(2ⁿ * 2^m)=O(2^m+n)。时间复杂度很高，在枚举各个子串时出现了很多重复，可以考虑使用动态规划思想。

动态规划：首先要判断动态规划思想是否适用本问题，即本问题是否具有最优子结构和重叠子问题性质。对于最有子结构的证明可用反证法：设{a₁,a₂,…,a_n}是str1,str2的最长公共子序列，若将str1,str2中的第一个等于a₁的字符删去，则{a₂,a₃,…,a_n}是str1,str2删去第一个等于a₁的两个串的最长公共子序列。若存在有更长的公共子序列，如{b₁,a₂,a₃,…,a_n}，那么对于原来的str1,str2的最长公共子序列的解应该是{b₁,a₁,a₂,a₃,…,a_n}与原来的条件相悖，则可证明本问题最优子结构的性质。重叠子问题的是显而易见，如暴力枚举时str1，str2会枚举到ac与ace后者会重新比较ac。
用动态规划解题最重要的便是定义状态和状态转移方程，然后最常见的便是填写一个（二维）数组，最后从数组中得出答案。本题我们可以定义一个二维数组dp[N][N],其中N>=max(str1.length,str2.length)，dp[i][j]为状态，定义为str1[0…i]与str2[0…j]的最长公共子序列，注意下标左右均为闭区间。状态转移方程为：
$$dp[i][j]=\{\begin{array}{ll}& \text{dp[i-1][j-1]+1 if (str1[i]==str2[j]) （注意边界条件）}\\ & \text{max(dp[i-1][j],dp[i][j-1]) if(str1[i]!=str2[j])}\end{array}$$
二维数组填写时从上到下从左到右即可，最后答案为dp[str1.length-1][str2.length-1]
题解代码

class Solution {
public:
    int dp[1001][1001];
    int longestCommonSubsequence(string text1, string text2) {
        int len1=text1.length();
        int len2=text2.length();

        for(int i=0;i<len1;i++){
            for(int j=0;j<len2;j++){
                dp[i][j]=0;
            }
        }
        if(text1[0]==text2[0]){
            dp[0][0]=1;
        }else{
            dp[0][0]=0;
        }
		//给第一行第一列符值，即添加围墙，防止越界，减少判断
        for(int i=1;i<len1;i++){
            if(text1[i]==text2[0]){
                dp[i][0]=1;
            }else{
                dp[i][0]=dp[i-1][0];
            }
            
        }
        for(int j=1;j<len2;j++){
            if(text1[0]==text2[j]){
                dp[0][j]=1;
            }else{
                dp[0][j]=dp[0][j-1];
            }
        }
        /*
        状态的定义：dp[i][j]表示str1[0....i]与str2[0....j]的最长公共子序列，注意下标左右均为闭区间。
        状态转移方程：
      				dp[i-1][j-1]+1   str1[i]==str2[j]
        dp[i][j]=
        			max(dp[i-1][j],dp[i][j-1])  str1[i]!=str2[j]
        */
        for(int i=1;i<len1;i++){
            for(int j=1;j<len2;j++){
                if(text1[i]==text2[j]){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else{
                    dp[i][j]=dp[i-1][j]>dp[i][j-1]?dp[i-1][j]:dp[i][j-1];
                }
            }
        }
        return dp[len1-1][len2-1];
    }
};

2.力扣718. 最长重复子数组，最长公共子串
题目描述
给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。

示例：
输入：
A: [1,2,3,2,1]
B: [3,2,1,4,7]
输出：3
解释：
长度最长的公共子数组是 [3, 2, 1] 。

解题思路
暴力解法可以通过枚举两个字符串str1,str2的全部非空子串，然后依次比较。一个长度为n的字符串的非空子串共有1+2+3+…+n=（n+1)*n/2，设str1.length=n，str2.length=m，则比较两个字符串的全部子串需要用一个双重循环，时间复杂度为O(n² * m²)。
动态规划本问题问题同样具有最优子结构和重叠子问题性质，本文不再做证明。对于两个字符串，我们还可以使用一个二维数组来记录和表示状态。本题中状态定义为：dp[i][j]定义为nums1[0…i]与nums2[0…j]的最长公共子数组（其实和子串一样），且公共子数字（子串）的结尾为nums1[i],nums2[j]。因为本题要求的子数字（子串）在原数字中必须的连续的，所以将状态定义为包含nums1[i],nums2[j]的子串，本质上算是两个串的公共后缀序列。所以状态方程定义为：
$$dp[i][j]=\{\begin{array}{ll}& \text{dp[i-1][j-1]+1 if (str1[i]==str2[j]) （注意边界条件）}\\ & \text{0 if(str1[i]!=str2[j])}\end{array}$$
二维数组填写时从上到下从左到右即可，填写数组同时记录最大值，因为最后答案不一定为dp[str1.length-1][str2.length-1]

题解代码

class Solution {
public:
    int dp[1001][1001];
    int findLength(vector<int>& A, vector<int>& B) {
        int lenA=A.size();
        int lenB=B.size();
        for(int i=0;i<lenA;i++){
            for(int j=0;j<lenB;j++){
                dp[i][j]=0;
            }
        }
        //给第一行第一列添加围墙，防止后续
        for(int i=0;i<lenB;i++){
            if(A[0]==B[i]){
                dp[0][i]=1;
            }
        }
        for(int i=0;i<lenA;i++){
            if(A[i]==B[0]){
                dp[i][0]=1;
            }
        }
        //填写数组
        int ans=0;
        for(int i=1;i<lenA;i++){
            for(int j=1;j<lenB;j++){
                if(A[i]==B[j]){
                    dp[i][j]=dp[i-1][j-1]+1;
                }else{
                    dp[i][j]=0;
                }
                if(dp[i][j]>ans){
                    ans=dp[i][j];
                }
            }
        }
        return ans;
    }
};

3.力扣300. 最长上升子序列
题目描述
给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

解题思路

暴力解法：可以通过枚举数组nums的全部非空子序列，然后依次判断是否为升序序列并记录子序列长度。一个长度为n的数组的非空子序列共有2ⁿ-1种，判断一个序列是否为升序序列的时间复杂度为O(n),所以总的时间复杂度为O(2ⁿ *n)。时间复杂度很高，在枚举各个子串时出现了很多重复，可以考虑使用动态规划思想。
动态规划本题中可以使用一个一维数组来记录状态，状态定义为dp[i]表示nums[0…i]中包含nums[i]的最长上升子序列，注意这里与上题一样都是包含nums[i]。状态转移方程为：
dp[i]=max(dp[j])+1, 其中0≤j<i且num[j]<num[i]

题解代码

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len=nums.size();
        if(len<1) return 0;
        int* dp=new int[len];
        //初始化，全部定义为1，因为单个数字是长度为1的上升子序列
        for(int i=0;i<len;i++) dp[i]=1;
        
        int ans=1;
        int temp;
        for(int i=1;i<len;i++){
            temp=1;
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                    temp=temp>(dp[j]+1)?temp:(dp[j]+1);    
                }
            }
            dp[i]=temp;
            if(dp[i]>ans){
                ans=dp[i];
            }
        }
        return ans;
    }
};