代码随想录Day43 | 300.最长递增子序列,674.最长连续递增序列,718.最长重复子数组

代码随想录Day43 | 300.最长递增子序列,674.最长连续递增序列,718.最长重复子数组

300.最长递增子序列

dp[i]定义：从 0-i 范围内计算，以 nums[i] 为结尾的最长严格递增子序列的长度。

状态转移方程：

if (nums[i] > nums[j])

​ dp[i] = Math.max(dp[i], dp[j] + 1);

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        // dp[i]定义：从 0-i 范围内计算，以 nums[i] 为结尾的最长严格递增子序列的长度
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        int res = 1;

        for (int i = 1; i < n; i++) {
            // 循环 0 - i-1 ,若 nums[i] > nums[j]，说明子序列可以延长一位
            // 且取其中最大值
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j])
                    dp[i] = Math.max(dp[i], dp[j] + 1);
            }
            // 返回值为dp中的最大值
            res = Math.max(res, dp[i]);
        }

        return res;
    }
}

674.最长连续递增序列

状态转移

dp[i] = nums[i] > nums[i - 1] ? dp[i - 1] + 1 : 1

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = 1;
        int res = 1;

        for (int i = 1; i < n; i++) {
            // 状态转移
            dp[i] = nums[i] > nums[i - 1] ? dp[i - 1] + 1 : 1;
            res = Math.max(res, dp[i]);
        }

        return res;
    }
}

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int n = nums.length;
        // 空间优化，dp[i] 只依赖于 dp[i - 1]
        int dp = 1;
        int res = 1;

        for (int i = 1; i < n; i++) {
            // 状态转移
            dp = nums[i] > nums[i - 1] ? dp + 1 : 1;
            res = Math.max(res, dp);
        }

        return res;
    }
}

718.最长重复子数组

dp[i][j]定义：

以 nums1[i-1] 和 nums2[j-1] 结尾的最长公共子数组长度

状态转移:

若nums1[i - 1] == nums2[j - 1]，dp[i][j]等于dp[i - 1][j - 1] + 1；

否则为0

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        // dp[i][j]定义：
        // 以 nums1[i-1] 和 nums2[j-1] 结尾的最长公共子数组长度
        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]);
                } else {
                    dp[i][j] = 0;
                }
            }
        }
        return maxLen;
    }
}

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        // dp[i][j]定义：
        // 以 nums1[i-1] 和 nums2[j-1] 结尾的最长公共子数组长度
        // 一维数组优化版
        int[] dp = new int[n + 1];
        int maxLen = 0;
        for (int i = 1; i <= m; i++) {
            for (int j = n; j >= 1; j--) {
                // 状态转移：
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[j] = dp[j - 1] + 1;
                    maxLen = Math.max(maxLen, dp[j]);
                } else {
                    dp[j] = 0;
                }
            }
        }
        return maxLen;
    }
}