算法练习第五十二天|300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组

300. 最长递增子序列
674. 最长连续递增序列
718. 最长重复子数组

300. 最长递增子序列、

class Solution {
    public int lengthOfLIS(int[] nums) {

        if (nums.length <= 1) return nums.length;
        //dp[i]以nums[i]为结尾的最长子序列长度

        //递推公式
        //dp[i] = Math.max(dp[j] + 1,dp[i])
        int[] dp = new int[nums.length];
        Arrays.fill(dp, 1);
        int result = 0;
        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[j] + 1,dp[i]);
                }
            }
            result = Math.max(result,dp[i]);

        }

        return result;
    }
}

674. 最长连续递增序列

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        //以下标i为结尾的连续递增的子序列长度为dp[i]

        /**
        
        如果 nums[i] > nums[i - 1]，
        那么以 i 为结尾的连续递增的子序列长度 一定等于 
        以i - 1为结尾的连续递增的子序列长度 + 1 。
        即：dp[i] = dp[i - 1] + 1;
         */
        if(nums.length <=1) return nums.length;
        int dp[] = new int[nums.length];
        Arrays.fill(dp,1);
        int res = 0;
        for(int i = 1;i<nums.length;i++){
            if(nums[i] > nums[i-1]){

                dp[i] = dp[i-1] +1;
            }
            res = Math.max(dp[i],res);
        }
        return res;
    }
}

718. 最长重复子数组

class Solution {
    //使用滑动窗口
    // public int findLength(int[] nums1, int[] nums2) {
    //     int maxLength = 0;
    //     int m = nums1.length, n = nums2.length;
        
    //     // 滑动窗口的起始位置
    //     for (int i = 0; i < m; i++) {
    //         int len = 0;
    //         // 计算窗口的长度
    //         int windowLen = Math.min(m - i, n);
    //         // 比较两个数组中对应位置的元素是否相等
    //         for (int j = 0; j < windowLen; j++) {
    //             if (nums1[i + j] == nums2[j]) {
    //                 len++;
    //                 maxLength = Math.max(maxLength, len);
    //             } else {
    //                 len = 0; // 如果当前位置元素不相等，则重置子数组长度
    //             }
    //         }
    //     }
        
    //     // 滑动窗口的起始位置
    //     for (int i = 0; i < n; i++) {
    //         int len = 0;
    //         // 计算窗口的长度
    //         int windowLen = Math.min(n - i, m);
    //         // 比较两个数组中对应位置的元素是否相等
    //         for (int j = 0; j < windowLen; j++) {
    //             if (nums2[i + j] == nums1[j]) {
    //                 len++;
    //                 maxLength = Math.max(maxLength, len);
    //             } else {
    //                 len = 0; // 如果当前位置元素不相等，则重置子数组长度
    //             }
    //         }
    //     }
        
    //     return maxLength;
    // }

    
    public int findLength(int[] nums1, int[] nums2) {

        //dp[i][j]以下标i - 1为结尾的nums1，和以下标j - 1为结尾的nums2，最长重复子数组长度为dp[i][j]
        
        //递推公式
        //dp[i][j] = dp[i-1][j-1] +1;

        int result = 0;
        int[][] dp = new int[nums1.length+1][nums2.length+1];

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

        return result;
    }
}