【代码随想录Day52】动态规划

最新推荐文章于 2024-09-14 22:25:23 发布

lisatse0115

最新推荐文章于 2024-09-14 22:25:23 发布

阅读量89

点赞数

分类专栏：代码随想录文章标签：动态规划算法 leetcode Powered by 金山文档

本文链接：https://blog.csdn.net/lisatse0115/article/details/129389883

版权

代码随想录专栏收录该内容

53 篇文章 0 订阅

订阅专栏

本文探讨了动态规划在解决LeetCode算法题目的应用，包括300题最长递增子序列、647题最长连续递增序列和718题最长重复子数组。通过分析题目和给出的链接，我们可以深入理解动态规划的解题策略和思路。

摘要由CSDN通过智能技术生成

300 最长递增子序列

https://leetcode.cn/problems/longest-increasing-subsequence/

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        int globalMax = 1;
        Arrays.fill(dp, 1);
        for (int i  = 1; i < nums.length; i++) {                                            
            for (int j = 0; j < i; j++) {
                if(nums[j] < nums[i]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            globalMax = Math.max(globalMax, dp[i]);
        }
        return globalMax;
    }
}

647 最长连续递增序列

https://leetcode.cn/problems/longest-continuous-increasing-subsequence/

只看前面一位数能不能连。

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int globalMax = 1;
        int len = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                len += 1;
            } else {
                len = 1;
            }
            globalMax = Math.max(globalMax, len);
        }
        return globalMax;
    }
}

718 最长重复子数组

https://leetcode.cn/problems/maximum-length-of-repeated-subarray/

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];  //以 i, j为结尾的
        int globalMax = 0;
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                if (nums1[i] == nums2[j]) {
                    dp[i + 1][j + 1] = dp[i][j] + 1;
                } 
                globalMax = Math.max(globalMax, dp[i + 1][j + 1]);
            }
        }
        return globalMax;
    }
}

class Solution {  //一维滚动
    public int findLength(int[] nums1, int[] nums2) {
        int[] dp = new int[nums2.length + 1];  
        int globalMax = 0;
        for (int i = 0; i < nums1.length; i++) {
            for (int j = nums2.length - 1; j >= 0; j--) {  //转为一维滚动数组时，需要从后往前填避免覆盖j-1
                if (nums1[i] == nums2[j]) {
                    dp[j + 1] = dp[j] + 1;
                } else {
                    dp[j + 1] = 0;                 //bug，一维滚动时需要手动重置为0
                }
                globalMax = Math.max(globalMax, dp[j + 1]);
            }
        }
        return globalMax;
    }
}