代码随想录刷题笔记 Day 56 | 最长递增子序列 No.300 |最长连续递增序列 No.674 | 最长重复子数组 No.718

最新推荐文章于 2024-06-15 11:56:23 发布

*Soo_Young*

最新推荐文章于 2024-06-15 11:56:23 发布

阅读量604

点赞数 19

分类专栏：代码随想录文章标签：笔记动态规划算法 java

本文链接：https://blog.csdn.net/weixin_74895237/article/details/136923956

版权

代码随想录专栏收录该内容

43 篇文章 4 订阅

订阅专栏

文章目录

- Day 56

Day 56

01. 最长递增子序列（No. 300）

题目链接

代码随想录题解

<1> 题目

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

<2> 笔记

1. 状态

本题最难的是考虑出 哪个状态可以转移？

最容易想出来的肯定是：对于一个元素有 取或者不取 两种状态，就将状态设定为考虑第 i 个元素的取或者不取，能得到的最优状态。

对于不取的状态，它的最优解就是从 0 到 i - 1，的两种状态的最优解。

对于取的状态，一定是基于 nums[j] < num[i] (j < i) 的情况下推导出来的，在这个基础上加一，因为对于从 0 到 i 如果选择取得 nums[i] 的话，那 nums[i] 一定是此时子序列的 最后一个元素。

语言不好理解的话可以看后面的递推方程部分。

这部分是对上面方法的优化：

通过上面的方法可以发现，dp[i][1] 的推导，其实和 dp[i][0] 是没有关系的。它的推导是通过 以一个比 num[i] 小的数字作为结尾的子序列加上一得出的。

那其实就可以想出另一个可以转移的状态：以 nums[i] 作为结尾的最长子序列的长度。

2. dp 数组的定义

对于取或者不取两种状态，则定义为一个二维数组 dp[i][2]，i 表示第 i 个元素的状态，列表示它的每个状态，即 dp[i][0] 为不取这个元素的最优解，dp[i][1] 为取这个元素的最优解。

优化后可以采用一维数组的方式来存储数据，dp[i] 表示以 nums[i] 结尾的子序列的最大长度。

3. 递推公式

如果不取这个节点的话，那就是前面某个节点的最优解：

for (int j = 0; j < i; j++) {
    dp[i][0] = Math.max(dp[i][0], dp[j][0]);
    dp[i][0] = Math.max(dp[i][0], dp[j][1]);
}

如果要取得这个节点的话，那只能在 最终取得的节点比该节点的值小的情况下取得，写出递推公式就是这样：

for (int j = 0; j < i; j++) {
	if (nums[i] > nums[j]) {
        // dp[i][1] 初始化为 1
		dp[i][1] = Math.max(dp[i][1], dp[j][1] + 1);
	}
}

优化后其实就只需要用第二个递推公式即可，遍历思路和上面的相同，仍然每次从头开始寻找：
if (nums[i] > nums[j]) dp[i] = Math.max(dp[i], dp[j] + 1);
但是此时 收集数据的位置 改变了，因为此时 dp[i] 的定义变成了以 nums[i] 为结尾的序列的长度，所以任意一个数组中的值都有可能是最终的结果，所以每次得到一个新的 dp[i] 都要进行一次收集结果。

4. 初始化

本题的初始化和之前有所不同，注意这个递推公式：dp[i][1] = Math.max(dp[i][1], dp[j][1] + 1); 如果简单的将这个值初始化为 0，那如果前面没有比 num[i] 小的值，那这个值就会 保持 0，而通过题意可以直到，这个值应该为 1。

所以所有的 dp[i][1] 都应该初始化为 1。

初始化的思路和上面相同

<3> 代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[][] dp = new int[nums.length][2];
        for (int i = 0; i < dp.length; i++) {
            // 初始化
            dp[i][1] = 1;
        }
        for (int i = 1; i < nums.length; i++) {
            // 遍历数组
            for (int j = 0; j < i; j++) {
                // 从头开始寻找比其小的值
                dp[i][0] = Math.max(dp[i][0], dp[j][0]);
                dp[i][0] = Math.max(dp[i][0], dp[j][1]);
                if (nums[i] > nums[j]) {
                    dp[i][1] = Math.max(dp[i][1], dp[j][1] + 1);
                }
            }
            System.out.println(dp[i][0] + " " + dp[i][1]);
        }
        // 取最大值
        return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
    }
}

优化

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        for (int i = 0 ; i < dp.length; i++) {
            dp[i] = 1;
        }
        int res = 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);
            }
            res = Math.max(dp[i], res);
        }
        return res;
    }
}

02. 最长连续递增序列（No. 674）

<1> 题目

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

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

<2> 笔记

1. 贪心思路

本题的贪心思路还是比较容易想出来的，对于每一个元素无非就两种情况

我比前面的大，结果中继续加上我
我比前面的小，子序列从我开始计数

每次将得到的 count 利用全局变量 res 记录下来，得到最大的那个直接返回即可，因为思路和方法都比较简单，这里直接给出代码

    public static int findLengthOfLCIS(int[] nums) {
        if (nums.length <= 1) return nums.length;
        int res = 1; // 连续子序列最少也是 1
        int count = 1;
        for (int i = 1; i < count + nums.length - res; i++) {
            if (nums[i] > nums[i - 1]) { // 连续记录
                count++;
            } else { // 不连续，count从头开始
                count = 1;
            }
            res = Math.max(res, count);
        }
        return res;
    }

2. 动态规划思路

其实本题用动态规划去处理意义并不是很大，和贪心几乎就是相同的思路。

（1） 状态

首先考虑一下本题的状态是什么呢？和上题比较类似，是以 nums[i] 结尾的最长连续子序列的个数。

（2） dp 数组的定义

直接一维数组存储内容即可，dp[i] 表示以 nums[i] 结尾的最长子序列的个数。

（3） 状态转移方程

同样由两种方式，继续以前面的序列和从这个序列开始计算新的子序列

 if (nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;
 else dp[i] = 1;

同样也是需要在每次取最大的那个作为结果，因为以哪个元素作为结尾的子序列都有可能是最终结果

res = Math.max(res, count);

<3> 代码

贪心算法

    public static int findLengthOfLCIS(int[] nums) {
        if (nums.length <= 1) return nums.length;
        int res = 1; // 连续子序列最少也是 1
        int count = 1;
        for (int i = 1; i < count + nums.length - res; i++) {
            if (nums[i] > nums[i - 1]) { // 连续记录
                count++;
            } else { // 不连续，count从头开始
                count = 1;
            }
            res = Math.max(res, count);
        }
        return res;
    }

动态规划

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int[] dp = new int[nums.length];
        dp[0] = 1;
        int res = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) dp[i] = dp[i - 1] + 1;
            else dp[i] = 1;
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

03. 最长重复子数组（No. 718）

题目链接

代码随想录题解

<1> 题目

给两个整数数组 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]
输出：

提示：

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

<2> 笔记

1. 滑动对齐解法

观察题目中的第一个案例，想象有两个数组，它们相互相对滑动：

在这里插入图片描述

在滑动的过程中必然会出现 重叠的部分：

在这里插入图片描述

而这个重叠的部分就是题目中提到的 公共子数组。

两者相互滑动，直到两者没有重叠部分的时候，其实就遍历完了所有公共子数组的情况，在其中最优解是如下的部分：

在这里插入图片描述

所以本题的思路就是先固定一个数组，然后滑动另一个数组，比如说先固定 nums1 对重叠的部分计算公共的个数：

在这里插入图片描述

比如这个就是在 1 2 3 和 1 4 7 中寻找重叠的部分，得到的重复子数组的长度就是 1。

然后再固定另一个数组，滑动上次固定的那个数组，重复执行上述的操作

为什么要加这一步呢？

固定数组一滑动数组二是是遍历了这一部分

在这里插入图片描述

还有向左的一部分没有遍历完：

在这里插入图片描述

所以需要固定数组 1 来再次遍历。

现在来看一下具体的实现，先写一个固定 nums1，滑动 nums2 的函数

public int getRes(int[] nums1, int[] nums2) {
    int res = 0;
    int temp = 0;
    for (int i = 0; i < nums1.length; i++) {
        int k = i; // nums1 的下标
        for (int j = 0; j < nums1.length - i && j < nums2.length; j++) {
            // 遍历 nums2 从 0 到 nums1.length - i 的部分
            if (nums1[k++] == nums2[j]) {
                temp++;
                res = Math.max(temp, res);
            } else {
                res = Math.max(temp, res);
                temp = 0;
            }
        }
        temp = 0;
    }
    return res;
}

来看一个具体的案例，比如本次遍历中，k 将从 2 遍历到 4，而 j 将从 0 变为 2。

在这里插入图片描述

将这个案例带入到上面的代码会比较好理解。

然后再固定 nums2 滑动 nums1 就可以得到结果。

int res1 = getRes(nums1, nums2);
int res2 = getRes(nums2, nums1);
return Math.max(res1, res2);

<3> 代码

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int res1 = getRes(nums1, nums2);
        int res2 = getRes(nums2, nums1);
        return Math.max(res1, res2);
    }
    public int getRes(int[] nums1, int[] nums2) {
        int res = 0;
        int temp = 0;
        for (int i = 0; i < nums1.length; i++) {
            int k = i;
            for (int j = 0; j < nums1.length - i && j < nums2.length; j++) {
                if (nums1[k++] == nums2[j]) {
                    temp++;
                    res = Math.max(temp, res);
                } else {
                    res = Math.max(temp, res);
                    temp = 0;
                }
            }
            temp = 0;
        }
        return res;
    }
}

*Soo_Young*

关注

19
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
0
评论
代码随想录刷题笔记 Day 56 | 最长递增子序列 No.300 |最长连续递增序列 No.674 | 最长重复子数组 No.718

本题的初始化和之前有所不同，注意这个递推公式：dp[i][1] = Math.max(dp[i][1], dp[j][1] + 1); 如果简单的将这个值初始化为 0，那如果前面没有比 num[i] 小的值，那这个值就会保持 0，而通过题意可以直到，这个值应该为 1。所以所有的 dp[i][1] 都应该初始化为 1。
复制链接

扫一扫