JAVA代码编写
给你一个整数数组 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数组的变化如下:
复杂度分析:
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;
}
}
给定一个未经排序的整数数组,找到最长且 连续递增的子序列,并返回该序列的长度。
连续递增的子序列 可以由两个下标 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记录子序列起始位置,然后遍历,计算最大长度。
复杂度分析:
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
复杂度分析:
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;
}
}
代码逻辑看着挺简单的,自己写不出来
给两个整数数组 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]
为例子
复杂度分析:
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});
}
}