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

JAVA代码编写

300.最长递增子序列

给你一个整数数组 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

进阶：

• 你能将算法的时间复杂度降低到 O(n log(n)) 吗?

教程：https://programmercarl.com/0300.%E6%9C%80%E9%95%BF%E4%B8%8A%E5%8D%87%E5%AD%90%E5%BA%8F%E5%88%97.html

方法一：动态规划

**思路：**找到最长递增子序列

五部曲：

1.定义数组dp[i]: nums中1-i索引的最长递增子序列长度为dp[i]

2.递推公式

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

所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

3.dp数组如何初始化

dp[i]默认填充为1

4.遍历循序：从前向后

5.举例推导dp数组

输入：[0,1,0,3,2]，dp数组的变化如下：

复杂度分析：

• 时间复杂度：$O(n^2)$
• 空间复杂度：O(n)

class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1); // 初始化dp数组为1
        
        int maxLen = 1; // 记录最长递增子序列的长度
        
        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);
                }
            }
            maxLen = Math.max(maxLen, dp[i]);
        }
        
        return maxLen;
    }
}

674. 最长连续递增序列

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

连续递增的子序列 可以由两个下标 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

教程：https://programmercarl.com/0674.%E6%9C%80%E9%95%BF%E8%BF%9E%E7%BB%AD%E9%80%92%E5%A2%9E%E5%BA%8F%E5%88%97.html

方法一：双指针

**思路：**使用start记录子序列起始位置，然后遍历，计算最大长度。

复杂度分析：

• 时间复杂度：O(n)
• 空间复杂度：O(1)

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        
        int maxLen = 1; // 记录最长连续递增子序列的长度
        int start = 0; // 记录当前连续递增子序列的起始位置
        
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                maxLen = Math.max(maxLen, i - start + 1);
            } else {
                start = i;
            }
        }
        
        return maxLen;
    }
}

方法二：动态规划

**思路：**找到最长递增子序列

五部曲：

1.定义数组dp[i]: nums中1-i索引的最长递增子序列长度为dp[i]

2.递推公式

如果前后是递增的，就dp[i] = dp[i - 1] + 1;

3.dp数组如何初始化

dp[i]默认填充为1

4.遍历循序：从前向后

5.举例推导dp数组

以nums = [1,3,5,4,7]为例子

i=1 dp[1]=2 maxLen=2

i=2 dp[2]=3 maxLen=3

i=3 (默认dp[3]=1 ) maxLen=3

i=4 dp[4]=2 maxLen=3

所以最后返回3

复杂度分析：

• 时间复杂度：O(n)
• 空间复杂度：O(n)

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1); // 初始化dp数组为1
        
        int maxLen = 1; // 记录最长连续递增子序列的长度
        
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                dp[i] = dp[i - 1] + 1;
            }
            maxLen = Math.max(maxLen, dp[i]);
        }
        
        return maxLen;
    }
}

代码逻辑看着挺简单的，自己写不出来

718. 最长重复子数组

给两个整数数组 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

教程：https://programmercarl.com/0718.%E6%9C%80%E9%95%BF%E9%87%8D%E5%A4%8D%E5%AD%90%E6%95%B0%E7%BB%84.html

方法一：动态规划

思路：

五部曲：

1.定义二维数组dp[i] [j]:表示以nums1[i-1]和nums2[j-1]结尾的公共子数组的长度。

2.递推公式

if (nums1[i - 1] == nums2[j - 1]) {
    dp[i][j] = dp[i - 1][j - 1] + 1;
    maxLen = Math.max(maxLen, dp[i][j]);
}

3.dp数组如何初始化

默认都是0

4.遍历循序：从前向后，从上往下

5.举例推导dp数组

以nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]为例子

复杂度分析：

• 时间复杂度：$O(n^2)$
• 空间复杂度：O(n)

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int[][] dp = new int[m + 1][n + 1];
        int maxLen = 0;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    maxLen = Math.max(maxLen, dp[i][j]);
                }
            }
        }

        return maxLen;
    }


    public static void main(String[] args) {
        Solution solution = new Solution();
        solution.findLength(new int[]{1,2,3,2,1},new int[]{3,2,1,4,7});
    }
}