算法学习——LeetCode力扣动态规划篇8

在这里插入图片描述

300. 最长递增子序列

300. 最长递增子序列 - 力扣（LeetCode）

描述

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的
子序列
。

示例

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

提示

1 <= nums.length <= 2500
-104 <= nums[i] <= 104

代码解析

动态规划

dp[i]的定义
dp[i]表示i之前包括i的以nums[i]结尾最长上升子序列的长度
状态转移方程
位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。
所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值。
dp[i]的初始化
每一个i，对应的dp[i]（即最长上升子序列）起始大小至少都是1.
确定遍历顺序
dp[i] 是有0到i-1各个位置的最长升序子序列推导而来，那么遍历i一定是从前向后遍历。
j其实就是0到i-1，遍历i的循环在外层，遍历j则在内层

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size() ==1 ) return 1;
        vector<int> dp(nums.size() , 1);
        int result = 0;

        for(int i=0 ; i<nums.size() ;i++)
        {
            for(int j=0 ;j<i ;j++)
            {
                if(nums[i] > nums[j])
                    dp[i] = max(dp[i] , dp[j] + 1) ;
            }
            if(dp[i] > result) result = dp[i];
        }
        return result;
    }
};

674. 最长连续递增序列

674. 最长连续递增序列 - 力扣（LeetCode）

描述

给定一个未经排序的整数数组，找到最长且连续递增的子序列，并返回该序列的长度。

连续递增的子序列可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

示例

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。

示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。

提示

1 <= nums.length <= 104
-109 <= nums[i] <= 109

代码解析

动态规划

dp数组定义
i点前连续递增序列的个数
dp的迭代
if(nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1;
当i的值大于i-1，dp[i] = dp[i-1] + 1
dp初始化
全都设置为1
自己认为是一个元素的递增数组

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if(nums.size()==1) return 1;
        vector<int> dp(nums.size() ,1);
        int result = 0;
        for(int i=1 ; i<nums.size();i++)
        {
            if(nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1;
            if(dp[i]>result) result = dp[i];
        }

        return result;
    }
};

718. 最长重复子数组

718. 最长重复子数组 - 力扣（LeetCode）

描述

给两个整数数组 nums1 和 nums2 ，返回两个数组中公共的、长度最长的子数组的长度。

示例

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

提示

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 100

代码解析

动态规划

确定dp数组含义
dp[i][j] ：以下标i - 1为结尾的A（A的第i个元素），和以下标j - 1为结尾的B（B的第j个元素），最长重复子数组长度为dp[i][j]。
确定递推公式
根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。
即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
初始化
dp[0][0]、dp[i][0]、dp[0][j]都为0，因为下标为0意味着没有元素进行匹配，因此匹配的个数也是0。从dp[i][j]开始有意义，即nums1和nums2都拿出了一个元素

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
    	//dp数组下标i和j意味着第几个元素，因此长度+1
       vector<vector<int>>  dp(nums1.size()+1 , vector<int>(nums2.size()+1,0));
        int result = 0 ;
        for(int i=0 ; i<nums1.size() ;i++)
        {
            for(int j=0 ;j<nums2.size();j++)
            {
                if(nums1[i] == nums2[j])
                    dp[i+1][j+1] = dp[i][j]+1;
                if(dp[i+1][j+1] > result) result = dp[i+1][j+1];
            }
        
        }
         
        // for(int i=0 ; i<=nums1.size() ;i++)
        // {
        //     for(int j=0 ;j<=nums2.size();j++)
        //     {
        //         if(dp[i][j] > result) result = dp[i][j];
        //          cout<<dp[i][j]<<' ';
        //     }
        //      cout<<endl;
        // }
         return result;
    }
};

1143. 最长公共子序列

1143. 最长公共子序列 - 力扣（LeetCode）

描述

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。

一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的公共子序列是这两个字符串所共同拥有的子序列。

示例

示例 1：

输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace” ，它的长度为 3 。

示例 2：

输入：text1 = “abc”, text2 = “abc”
输出：3
解释：最长公共子序列是 “abc” ，它的长度为 3 。

示例 3：

输入：text1 = “abc”, text2 = “def”
输出：0
解释：两个字符串没有公共子序列，返回 0 。

提示

1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。

代码解析

dp数组含义
dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]（即前i个字符和前j个字符匹配）
递推公式
- 当text1[i] == text2[j]
  当前匹配的i和j是相同的字符，dp[i+1][j+1] = dp[i][j] + 1;
  dp应该是不包括第i+1 和第j+1字符之前匹配成功个数+1
  要把i+1和j+1让出来。
- 当text1[i] ！= text2[j]
  当前匹配的i和j是不同的字符，dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1]);
  dp为包括i+1字符或者包括j+1字符的最大值
- 当匹配成功时
  为什么不是 dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1])+1;
  因为会造成一个字母匹配多次
  例如 text1中有一个b，text2中有两个b
  在i+1为text1的b，j+1为text2中第二个b时：
  max(dp[i+1][j],dp[i][j+1])包含和text2中第一个b匹配，+1是和第二个b匹配。
  则造成了text1中字母b与text2中两个b分别匹配。
  因此应该是dp[i+1][j+1] = dp[i][j] + 1，这样让开要匹配的字符

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size()+1 , vector<int>(text2.size()+1 ,0) );

        for(int i=0 ;i<text1.size();i++)
        {
            for(int j=0; j<text2.size();j++)
            {
                
                if(text1[i] == text2[j])
                    dp[i+1][j+1] = dp[i][j] + 1; 
                else
                    dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1]);
                   
            }
        }
        //  for(int i=0 ;i<=text1.size();i++)
        // {
        //     for(int j=0; j<=text2.size();j++)
        //     {
        //         cout<<dp[i][j]<<' ';
        //     }
        //     cout<<endl;
        // }
        return dp[text1.size()][text2.size()];
    }
};