目录
674.最长连续递增序列
718.最长重复子数组
53.最大子数组和
674.最长连续递增序列
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
动规五部曲分析如下：
确定dp数组（dp table）以及下标的含义
dp[i]：以下标i为结尾的连续递增的子序列长度为dp[i]。
注意这里的定义，一定是以下标i为结尾，并不是说一定以下标0为起始位置。
确定递推公式
如果 nums[i] > nums[i - 1]，那么以 i 为结尾的连续递增的子序列长度 一定等于 以i - 1为结尾的连续递增的子序列长度 + 1 。
即：dp[i] = dp[i - 1] + 1;
注意这里就体现出和动态规划：300.最长递增子序列 (opens new window)的区别！
因为本题要求连续递增子序列，所以就只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）。
既然不用j了，那么也不用两层for循环，本题一层for循环就行，比较nums[i] 和 nums[i - 1]。
这里大家要好好体会一下！
dp数组如何初始化
以下标i为结尾的连续递增的子序列长度最少也应该是1，即就是nums[i]这一个元素。
所以dp[i]应该初始1;
确定遍历顺序
从递推公式上可以看出， dp[i + 1]依赖dp[i]，所以一定是从前向后遍历。
本文在确定递推公式的时候也说明了为什么本题只需要一层for循环，代码如下：
for (int i = 1; i < nums.size(); i++) {
if (nums[i] > nums[i - 1]) { // 连续记录
dp[i] = dp[i - 1] + 1;
}
}
举例推导dp数组
已输入nums = [1,3,5,4,7]为例，dp数组状态如下：
注意这里要取dp[i]里的最大值，所以dp[2]才是结果！
class Solution {
// 求解最长连续递增子序列的长度
public int findLengthOfLCIS(int[] nums) {
// 创建一个与输入数组长度相同的dp数组，用于保存以当前元素结尾的最长连续递增子序列的长度
int[] dp = new int[nums.length];
// 初始化dp数组，每个元素的最长连续递增子序列至少包含自身，所以初始长度为1
for(int i = 0; i < nums.length; i++){
dp[i] = 1;
}
// 初始化结果变量，至少为1（因为每个元素本身就是一个长度为1的连续递增子序列）
int result = 1;
// 遍历数组中的每个元素
for(int i = 1; i < nums.length; i++){
// 如果当前元素大于前一个元素，说明可以形成连续递增子序列
if(nums[i - 1] < nums[i]){
// 更新以当前元素结尾的最长连续递增子序列长度，即前一个元素的最长连续递增子序列长度加1
dp[i] = dp[i - 1] + 1;
}
// 更新全局的最长连续递增子序列长度
result = Math.max(result, dp[i]);
}
// 返回最长连续递增子序列的长度
return result;
}
}718.最长重复子数组
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
动规五部曲分析如下：
确定dp数组（dp table）以及下标的含义
dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）
为什么是i - 1为结尾，因为以i结尾在初始化数组的时候有困难
此时细心的同学应该发现，那dp[0][0]是什么含义呢？总不能是以下标-1为结尾的A数组吧。
其实dp[i][j]的定义也就决定着，我们在遍历dp[i][j]的时候i 和 j都要从1开始。
确定递推公式
根据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开始！
dp数组如何初始化
根据dp[i][j]的定义，dp[i][0] 和dp[0][j]其实都是没有意义的！
但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;
所以dp[i][0] 和dp[0][j]初始化为0。
举个例子A[0]如果和B[0]相同的话，dp[1][1] = dp[0][0] + 1，只有dp[0][0]初始为0，正好符合递推公式逐步累加起来。
确定遍历顺序
外层for循环遍历A，内层for循环遍历B。
那又有同学问了，外层for循环遍历B，内层for循环遍历A。不行么？
也行，一样的，我这里就用外层for循环遍历A，内层for循环遍历B了。
同时题目要求长度最长的子数组的长度。所以在遍历的时候顺便把dp[i][j]的最大值记录下来。
代码如下：
for (int i = 1; i <= nums1.size(); i++) {
for (int j = 1; j <= nums2.size(); j++) {
if (nums1[i - 1] == nums2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
}
if (dp[i][j] > result) result = dp[i][j];
}
}
举例推导dp数组
这个图贼重要，一秒看懂
拿示例1中，A: [1,2,3,2,1]，B: [3,2,1,4,7]为例，画一个dp数组的状态变化，如下：
class Solution {
// 求解两个数组的最长公共子序列的长度
public int findLength(int[] nums1, int[] nums2) {
// 创建一个二维dp数组，大小为(nums1.length + 1) x (nums2.length + 1)
// dp[i][j] 表示nums1的前i个元素和nums2的前j个元素的最长公共子序列的长度
int[][] dp = new int[nums1.length + 1][nums2.length + 1];
int result = 0; // 用于保存最长公共子序列的长度
// 遍历nums1的每个元素
for(int i = 1; i <= nums1.length; i++){
// 遍历nums2的每个元素
for(int j = 1; j <= nums2.length; j++){
// 如果nums1的第i个元素和nums2的第j个元素相等
if(nums1[i - 1] == nums2[j - 1]){
// 当前位置的最长公共子序列长度等于左上方位置的最长公共子序列长度加1
dp[i][j] = dp[i - 1][j - 1] + 1;
}
// 更新最长公共子序列的长度
result = Math.max(result, dp[i][j]);
}
}
// 返回最长公共子序列的长度
return result;
}
}53.最大子数组和
53. 最大子数组和
中等
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组
是数组中的一个连续部分。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入：nums = [1] 输出：1
示例 3：
输入：nums = [5,4,-1,7,8] 输出：23
提示：
1 <= nums.length <= 105-104 <= nums[i] <= 104
动规五部曲如下：
确定dp数组（dp table）以及下标的含义
dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。
确定递推公式
dp[i]只有两个方向可以推出来：
dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
nums[i]，即：从头开始计算当前连续子序列和
一定是取最大的，所以dp[i] = max(dp[i - 1] + nums[i], nums[i]);
dp数组如何初始化
从递推公式可以看出来dp[i]是依赖于dp[i - 1]的状态，dp[0]就是递推公式的基础。
dp[0]应该是多少呢?
根据dp[i]的定义，很明显dp[0]应为nums[0]即dp[0] = nums[0]。
确定遍历顺序
递推公式中dp[i]依赖于dp[i - 1]的状态，需要从前向后遍历。
举例推导dp数组
以示例一为例，输入：nums = [-2,1,-3,4,-1,2,1,-5,4]，对应的dp状态如下：
注意最后的结果可不是dp[nums.size() - 1]！ ，而是dp[6]。
在回顾一下dp[i]的定义：包括下标i之前的最大连续子序列和为dp[i]。
那么我们要找最大的连续子序列，就应该找每一个i为终点的连续最大子序列。
所以在递推公式的时候，可以直接选出最大的dp[i]。
class Solution {
// 定义一个公共方法，用于计算给定数组中的最大子数组和
public int maxSubArray(int[] nums) {
// 如果数组为空，直接返回0
if(nums.length == 0){
return 0;
}
// 定义一个动态规划数组dp，其长度与原始数组nums相同
// dp[i]表示以nums[i]为结尾的最大子数组和
int dp[] = new int[nums.length];
// 初始化dp数组的第一个元素为nums的第一个元素
dp[0] = nums[0];
// 初始化result为nums的第一个元素，因为最大子数组和至少为nums的某个元素
int result = nums[0];
// 从数组的第二个元素开始遍历
for(int i = 1; i < nums.length; i++){
// 对于每个位置i，有两种情况：
// 1. 如果nums[i]自己作为子数组的和更大，那么dp[i] = nums[i]
// 2. 否则，将nums[i]加到前面的最大子数组和dp[i-1]上，得到新的dp[i]
dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
// 更新result，如果dp[i]比当前的result大，则更新result为dp[i]
result = Math.max(dp[i], result);
}
// 返回最大子数组和
return result;
}
}
