动态规划：字符串系列

当遇见两个字符串s,t的动态规划问题时候，通常使用二维数组表示分别取两个字符串中的第i个元素和第j个元素，并根据s[i] == t[j]来选择不同的递推公式

一、动态规划：子序列

1、最长递增子序列（非连续）

300. 最长递增子序列

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

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

1）dp数组

dp[i]为以元素nums[i]结尾的最长递增子序列。

2）递推公式

位置i的最长升序子序列等于从0到i-1各个位置的最长升序子序列 + 1 的最大值。

            for(int j = i - 1; j >= 0; j--){
   
                if(nums[i] > nums[j]){
   
                    dp[i] = max(dp[i], dp[j] + 1);  //找到i前面最长的子序列
                }

3）初始化

每一个i，对应的dp[i]（即最长上升子序列）起始大小至少都是是1.

4）遍历顺序

从前到后

5）返回值

dp[i]记录的仅仅是以nums[i]结尾的子序列的最大值，但并不知道这些序列中到底哪个最大，因此需要比较全部的dp[i]，返回其中最大的

6）代码实现

class Solution {
   
public:
    int lengthOfLIS(vector<int>& nums) {
   
        if(nums.size() <= 1) return nums.size();  //特殊处理

        vector<int> dp(nums.size(), 1);  //dp数组初始化为1,
        
        int maxLen = 0;

        for(int i = 1; i < nums.size(); i++){
   
            for(int j = i - 1; j >= 0; j--){
   
                if(nums[i] > nums[j]){
   
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            maxLen = max(maxLen, dp[i]);  //选取最大的dp[i]返回
        }

        return maxLen;
    }
};

2、最长连续递增子序列（连续）

674. 最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。
连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i+ 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

和上一道题目相比，这道题目要求子序列是连续的，所以只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历），因此递推公式为if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;其他的不变

1)代码实现

class Solution {
   
public:
    int findLengthOfLCIS(vector<int>& nums) {
   
        if(nums.size() <= 1) return nums.size();  //特殊处理

        vector<int> dp(nums.size(), 1);  //初始化dp
        
        int maxLen = 0;
        for(int i = 1; i < nums.size(); i++){
   
            if(nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;
            maxLen = max(maxLen, dp[i]);
        }
        return maxLen;
    }
};

2）递增子序列总结

递增系序列是在一个数组内寻找最长的递增子序列，这种类型题一般是使用dp[i]为以元素nums[i]结尾的最长递增子序列

3、最长重复子数组（连续）

718. 最长重复子数组

给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度，要求重复子数组连续。

1）dp数组

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。
之所以这么表示，是为了初始化简单，在这样的定义下，dp[0][j]和dp[i][0]均是一个空串和另外一个数组的最长子数组，其结果肯定为0

2）递推公式

根据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;

3）初始化

dp[i][0] 和dp[0][j]初始化为0

4）遍历顺序

从前到后，两个数组循环嵌套谁在外面都可以

5）返回值

在题目的定义下，最长的重复子数组可能出现在任意位置，因此需要返回最大的dp[i][j]

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