代码随想录算法训练营第43天|LeetCode 300.最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组

1. LeetCode 300.最长递增子序列

题目链接：https://leetcode.cn/problems/longest-increasing-subsequence/description/
文章链接：https://programmercarl.com/0300.最长上升子序列.html
视频链接：https://www.bilibili.com/video/BV1ng411J7xP

思路：
1.dp[i]的定义
dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度
2.递推公式
位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。
所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
注意：这里前提是nums[i] > nums[j]，只有这种情况，才能使用dp[j]+1，更新dp[i]；也就是说，从0到i-1位置也存在nums[i] <= nums[j]的情况，这时就不考虑以该j位置结尾的最长子序列的长度了dp[j];
3.初始化
每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1.
4.确定遍历顺序
dp[i] 是有0到i-1各个位置的最长递增子序列 推导而来，那么遍历i一定是从前向后遍历。
j遍历0到i-1，那么是从前到后，还是从后到前遍历都无所谓，只要把0 到 i-1 的元素都遍历了就行了。 所以默认习惯 从前向后遍历。
遍历i的循环在外层，遍历j则在内层。
5.返回值
dp数组中的最大值

解法：
class Solution {
    public int lengthOfLIS(int[] nums) {
        //1.定义dp数组
        //dp[i]表示下标i之前（包括i）的以nums[i]结尾的最长递增子序列长度
        int[] dp = new int[nums.length];
        //2.递推公式
        /**
        if (nums[i] > nums[j]) {
            dp[i] = Math.max(dp[i],dp[j]+1);
        }
         */
         //3.初始化
         for (int i=0;i<nums.length;i++) {
            dp[i] = 1;
         }
         //4.遍历顺序
         int res = dp[0];
         for (int i=1;i<nums.length;i++) {
            for (int j=0;j<i;j++) {
                if (nums[i]>nums[j]) {
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
            if (dp[i]>res) {
                res = dp[i];
            }
         }

         return res;
    }
}

2. LeetCode 674. 最长连续递增序列

题目链接：https://leetcode.cn/problems/longest-continuous-increasing-subsequence/
文章链接：https://programmercarl.com/0674.最长连续递增序列.html#思路
视频链接：https://www.bilibili.com/video/BV1bD4y1778v

思路：
1.确定dp数组（dp table）以及下标的含义
dp[i]：dp[i]表示下标i之前（包括i）以nums[i]结尾的最长连续递增子序列的长度。
注意这里的定义，一定是以下标i为结尾，并不是说一定以下标0为起始位置。
2.确定递推公式
如果 nums[i] > nums[i - 1]，那么以 i 为结尾的连续递增的子序列长度 一定等于 以i - 1为结尾的连续递增的子序列长度 + 1 。
即：if (nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;
因为本题要求连续递增子序列，所以就只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）。既然不用j了，那么也不用两层for循环，本题一层for循环就行，比较nums[i] 和 nums[i - 1]。
3.dp数组如何初始化
以下标i为结尾的连续递增的子序列长度最少也应该是1，即就是nums[i]这一个元素。
所以dp[i]应该初始1;
4.确定遍历顺序
从递推公式上可以看出， dp[i + 1]依赖dp[i]，所以一定是从前向后遍历。
5.返回值
dp数组中的最大值

解法：
class Solution {
    public int findLengthOfLCIS(int[] nums) {
        //1.定义dp数组
        //dp[i]表示下标i之前（包括i）以nums[i]结尾的最长连续递增子序列的长度
        int[] dp = new int[nums.length];
        //2.递推公式
        /**
        if (nums[i]>nums[i-1]) {
            dp[i] = dp[i-1]+1;
        }
         */
        //3.初始化
        for (int i=0;i<nums.length;i++) {
            dp[i] = 1;
        }
        //4.遍历顺序 从前往后
        int res = dp[0];
        for (int i=1;i<nums.length;i++) {
            if (nums[i]>nums[i-1]) {
                dp[i] = dp[i-1]+1;
            }
            res = Math.max(res,dp[i]);
        }

        return res;
    }
}

3. LeetCode 718. 最长重复子数组

题目链接：https://leetcode.cn/problems/maximum-length-of-repeated-subarray/description/
文章链接：https://programmercarl.com/0718.最长重复子数组.html
视频链接：https://www.bilibili.com/video/BV178411H7hV

思路：
1.确定dp数组（dp table）以及下标的含义
dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。
int[][] dp = new int[nums1.length+1][nums2.length+1];
特别注意：
“以下标i - 1为结尾的A” 表明一定是以A[i-1]为结尾的字符串。
在遍历dp[i][j]的时候i 和 j都要从1开始。
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;
根据递推公式可以看出，遍历i 和 j 要从1开始！
3.dp数组如何初始化
dp[i][0] 和dp[0][j]初始化为0。
4.确定遍历顺序
外层for循环遍历A，内层for循环遍历B。
5.返回值
dp数组中的最大值

解法：
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        //1.定义dp数组
        //dp[i][j]表示以下标i-1结尾的子串a和以下标j-1结尾的子串b的公共最长子数组的长度
        int[][] dp = new int[nums1.length+1][nums2.length+1];
        //2.递推公式
        /**
        if (nums1[i-1]==nums2[j-1]) {
            dp[i][j] = dp[i-1][j-1] + 1;
        }
         */
        //3.初始化
        //4.遍历顺序
        int res = 0;
        for (int i=1;i<nums1.length+1;i++) {
            for (int j=1;j<nums2.length+1;j++) {
                if (nums1[i-1]==nums2[j-1]) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                }

                res = Math.max(res,dp[i][j]);
            }
        }

        return res; 
    } 
}