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^2) O(n2)
- 空间复杂度：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 <= 10000 <= 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^2) O(n2)
- 空间复杂度：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});
}
}
