【代码训练营】day52 | 300.最长递增子序列 & 674. 最长连续递增序列 & 718. 最长重复子数组

所用代码 java

最长递增子序列 LeetCode 300

题目链接：最长递增子序列 LeetCode 300 - 中等

思路

• dp[i]数组：以nums[i]为结尾（结果可能不是最后一个数）的最长递增子序列的长度
• 递推公式：dp[i] = max(dp[i], dp[j]+1)
  • nums[i] > nums[j] 的话就是dp[j] + 1 。就是i对应元素大于了j对应的元素，就得加一
  • 不大于就是本身
• 初始化：dp[i] = 1
• 遍历顺序：1<=i<nums.size() 0<j<i遍历0-i之间的的所有数
• 打印dp
• 结果：不是dp[nums.length-1]，因为以nums[nums.length-1]结尾的数的递增子序列可能不是最大的

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        // 初始化，每个元素至少有一个位
        Arrays.fill(dp,1);
        int result = 1;
        for (int i = 1; i < nums.length; i++) {
            // j循环遍历0-i之间的所有数
            // dp[j]表示以j结尾的最长递增子序列长度
            for (int j = 0; j < i; j++) {
                // 更新dp[i]
                if (nums[i] > nums[j]){
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
//                System.out.printf("\tjjdp[%d]=%d",j,dp[j]);
            }
//            System.out.printf("\tiidp[%d]=%d\n",i,dp[i]);

            result = Math.max(result,dp[i]);
        }
        return result;
    }
}

总结

重点在于搞懂dp[i]的含义，即以nums[i]结尾的最长递增子序列的长度。

j的含义就在于遍历到这个数时（小于i），当nums[i]>nums[j]，我们就会更新dp[i]的值，以保证最大的递增子序列。

最长连续递增序列 LeetCode 674

题目链接：最长连续递增序列 LeetCode 674 - 简单

思路

重点在于取连续区间的最大值，连续的话就只用和nums[i-1]相比，不用和i-1之前的数相比。

• dp[i]：以i结尾的nums[i]最长的连续递增子序列为dp[i]
• 递推公式：if (nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1
• 初始化：dp[i] = 1 ，也可以初始化dp[0]=1，后面else也可以进行赋值
• 遍历顺序：1<=i<nums.length
• 打印
• 结果：并不是dp[nums.length-1]，因为以nums[nums.length-1]结尾的数的递增子序列可能不是最大的

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++) {
            // dp[i]只用和前一位进行比较，然后更新
            if (nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1;
            result = result > dp[i] ? result : dp[i];
        }
        return result;
    }
}

总结

求最长子序列重点在于所求子序列是否要求连续。

• 若连续，如本题：就只用和前一个数比较就好了，只用一个for
• 若不连续，如上一题：就需要和前面的每一个数相比较，所有需要定义一个j来遍历0-i之间的每一个数

最长重复子数组 LeetCode 718

题目链接：最长重复子数组 LeetCode 718 - 中等

思路

主要是需要一个二维的dp数组，一个值记录i下标，一个值记录j下标

• dp[i] [j]：以i-1为结尾的nums1 和 以j-1结尾的nums2数组的最长重复字符数组的长度为dp[i] [j]
• 递推公式：if(nums1[i-1] == nums2[j-1]) dp[i][j] = dp[i-1][j-1] + 1
• 初始化：dp[i][0] = 0 dp[0][j] = 0 这两个状态无意义的，其他也初始化为0，因为一开始不知道有没有相等，所有先等于0，后面再覆盖
• 遍历顺序：先遍历i或j都可以 1<=i<=nums1.length 1<=j<=nums2.length 后面的i，小于等于是为了能表示最后一个元素以满足我们dp[i] [j]的含义
• 打印
• 结果：并不一定是在dp[nums1.length] [nums2.length]，而是可能在前面的某个点

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length+1][nums2.length+1];
        int res = 0;
        // dp[i][0]和dp[0][j]默认初始化为0
        for (int i = 1; i <= nums1.length; i++) {
            for (int j = 1; j <= nums2.length; j++) {
                // 以i-1为结尾的nums1和以j-1为结尾的nums2的最大重复子数组长度为dp[i][j]
                // 这个数相等了，就在i-1和j-1的基础上+1
                if (nums1[i-1] == nums2[j-1]){
                    dp[i][j] = dp[i-1][j-1] + 1;
                    res = Math.max(res, dp[i][j]);
                }
            }
        }
        return res;
    }
}

总结

从递推公式可以看成，我们i，j这个状态的值全部来自于前一个状态，所有可以压缩成一个一维的数组。

注意：

1. j必须从后往前遍历，因为对于上一个确定的i，j，我们下一次需要使用他的结果，所以从后往前遍历以免覆盖之前的值。
2. 若不相等得置dp[j]=0，因为这一轮的结果是下一轮需要的，若我们不匹配就得把值置0，以便告诉下一轮我们在i-1的情况下没有相等的值。

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        // 因为nums2后遍历，所有只用定义这么长
        int[] dp = new int[nums2.length+1];
        int res = 0;
        for (int i = 1; i <= nums1.length; i++) {
            // 由于每次dp[j]需要用到dp[j-1]的结果，所以应该从后往前遍历
            for (int j = nums2.length; j > 0; j--) {
                if (nums1[i-1] == nums2[j-1]){
                    dp[j] = dp[j-1] + 1;
                    res = Math.max(res,dp[j]);
                }else {
                    // 若不相等一定要赋值为0，因为我们下一次i+1开始，匹配的是新的i于j了
                    dp[j] = 0;
                }
            }
        }
        return res;
    }
}