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

题目与题解

300.最长递增子序列

题目链接：300.最长递增子序列

代码随想录题解：​​​​​​​300.最长递增子序列

视频讲解：动态规划之子序列问题，元素不连续！| LeetCode：300.最长递增子序列_哔哩哔哩_bilibili

解题思路：

        一开始没有理清楚dp的含义，递推公式七改八改面目全非了，直接看答案。

看完代码随想录之后的想法 

        dp含义：dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度。因此dp[i]表示的这个序列长度必须是包括元素nums[i]的，比如0,4,5,2,3 这个序列，nums[3]是2，序列必须包含2，此时的dp[3]表示包含2的最长递增子序列长度，该序列为0,2，dp[3]=2.

        因此按顺序第一层遍历nums[i]，第二层遍历nums[j]（j < i），如果nums[i] > nums[j]则可以加入0-j递增子序列，dp[i]取其中最大的dp[j]+1，同时用result记录dp[i]的最大值。初始化dp[i]中的每个数为1，表示序列仅包含当前nums[i]时，长度至少为1。

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

遇到的困难

        一开始自己想的dp定义是对于nums[0]-nums[i]的数组，其最长递增子序列长度，但是序列可以不包括nums[i]，那后面出现nums[i]变小时，实际序列长度的计算就出了问题。这题定义上还是有点绕的。

674. 最长连续递增序列

题目链接：​​​​​​​674. 最长连续递增序列

代码随想录题解：674. 最长连续递增序列

视频讲解：动态规划之子序列问题，重点在于连续！| LeetCode：674.最长连续递增序列_哔哩哔哩_bilibili

解题思路：

        跟上一题有点类似，不同点在于一个求的是序列，可以不连续。而这题要求最长连续递增序列，那么递推公式中dp[i]只能与dp[i-1]相关，否则就不连续了。

        dp[i]的定义还是和上一题类似，表示包含nums[i]的最长连续递增子序列的长度。因此dp初始化仍为1。如果nums[i] > nums[i-1]，说明此处存在连续递增序列，dp[i]就可以在dp[i-1]的基础上加一了。同样用result记录中途的最大dp[i]，最后返回result即可。

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

看完代码随想录之后的想法 

        贪心也可以做，比较简单，如果nums[i] > nums[i-1]，count++，否则count归1，中途记录最大count即可。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        int result = 1; // 连续子序列最少也是1
        int count = 1;
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] > nums[i - 1]) { // 连续记录
                count++;
            } else { // 不连续，count从头开始
                count = 1;
            }
            if (count > result) result = count;
        }
        return result;
    }
};

与前一题关系：概括来说，不连续递增子序列的跟前0-i 个状态有关，连续递增的子序列只跟前一个状态有关 

遇到的困难

        无

718. 最长重复子数组  

题目链接：​​​​​​​718. 最长重复子数组  

代码随想录题解：​​​​​​​718. 最长重复子数组  

视频讲解：动态规划之子序列问题，想清楚DP数组的定义 | LeetCode：718.最长重复子数组_哔哩哔哩_bilibili

解题思路：

        仍旧是没想清楚dp的定义，看答案。

看完代码随想录之后的想法 

        dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）。定义是和前面类似的，要求的最长重复子数组必然包含nums1[i]和nums2[j]。

        确定递推公式

根据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和nums数组下标一一对应的方法，就是需要多初始化一次0行和0列。随想录给的答案相当于为了计算，多给了一圈没有含义的dp。

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
		int[][] dp = new int[nums1.length][nums2.length];
		int result = 0;
// 初始化dp的第一行和第一列
		for (int i = 0; i < nums1.length; i++) {
			if (nums1[i] == nums2[0]) {
				dp[i][0] = 1;
				result = 1;
			}
		}
		for (int j = 0; j < nums2.length; j++) {
			if (nums1[0] == nums2[j]) {
				dp[0][j] = 1;
				result = 1;
			}
		}
		for (int i = 1; i < nums1.length; i++) {
			for (int j = 1; j < nums2.length; j++) {
				if (nums1[i] == nums2[j]) {
					dp[i][j] = dp[i-1][j-1] + 1;
				}
				result = Math.max(dp[i][j], result);
			}
		}
		return result;
    }
}

 还可以用滚动数组做，因为dp[i][j]的状态只跟dp[i-1][j-1]相关，所以保留两个值的滚动数组就行

// 版本一
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int result = 0;
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        
        for (int i = 1; i < nums1.length + 1; i++) {
            for (int j = 1; j < nums2.length + 1; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    result = Math.max(result, dp[i][j]);
                }
            }
        }
        
        return result;
    }
}

// 版本二: 滚动数组
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[] dp = new int[nums2.length + 1];
        int result = 0;

        for (int i = 1; i <= nums1.length; i++) {
            for (int j = nums2.length; j > 0; j--) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[j] = dp[j - 1] + 1;
                } else {
                    dp[j] = 0;
                }
                result = Math.max(result, dp[j]);
            }
        }
        return result;
    }
}

遇到的困难

        dp的定义非常重要，理清楚了才能写出正确的递推公式。

今日收获

        学习了一系列数组序列相关的动态规划题，有一点点感觉了。