代码随想录刷题|LeetCode 1143.最长公共子序列 1035.不相交的线 53. 最大子序和动态规划

最新推荐文章于 2024-06-25 18:34:01 发布

symdunstaz

最新推荐文章于 2024-06-25 18:34:01 发布

阅读量366

点赞数

分类专栏： LeetCode学习笔记文章标签： leetcode 动态规划算法 java

本文链接：https://blog.csdn.net/m0_62575233/article/details/128163883

版权

LeetCode学习笔记专栏收录该内容

61 篇文章 0 订阅

订阅专栏

1143.最长公共子序列

题目链接：力扣

思路

不知道为什么，子序列问题的动态规划感觉比背包问题和买卖股票问题这两类题目难理解很多，比较了以下，可能是因为之前的数组，横列数列代表的都是不同的东西，而序列问题横列和数列代表的都是字符串本身，可能是这个原因吧，还不太清楚

可以看一下这个视频的图表推导：对照着代码更容易理解：最长公共子序列

1、确定dp数组

dp[i][j]：长度为[0, i]的字符串text1与长度为[0, j]的字符串text2的最长公共子序列为dp[i][j]

2、确定递推公式

两种情况：

text1[ i ] 与 text2[ j ]相同
- 那就是找到了一个公共元素，所以：dp[ i ][ j ] = dp[i - 1][j - 1] + 1;
text1[ i ] 与 text2[ j ]不相同
- 那就要看看长度为[0, i - 1]的text1与长度为[0 , i]的text2 的最长公共子序列
  与长度为[0, i ]的text1与长度为[0 , i - 1]的text2 的最长公共子序列
  这两个哪个最大，取最大的
  
  所以：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

最终的代码就为

if (text1[i - 1] == text2[j - 1]) {
    dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}

3、dp数组初始化

dp[i][0] 表示：长度为[0, i ]的text1 与空串的最长公共子序列，那肯定是 0 ，所以dp[i][0] = 0;

同理：dp[0][j] = 0

其他的会根据上面的一列一行，计算覆盖，所以赋值什么都可以的，所以统一默认为0 就行

4、遍历顺序

从前向后遍历

5、推导dp数组

dp数组的行和列是比两个字符串的长度多1的，这是一个面对代码不太好理解的点

所以在遍历字符串的时候都是从1开始，求的第一个其实就是 dp[1][1] ,但是此时是根据初始化的那部分来求的，此时是字符串以下标的 0 和 0 结尾的字符串，但是是dp数组的[1][1]

最长公共子序列

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        
        // 创建dp数组
        int[][] dp = new int[text1.length() + 1][text2.length() + 1];

        // 初始化dp数组
        // 默认就是初始化

        // 推导dp数组
        for (int i = 1; i <= text1.length(); i++) {
            char chi = text1.charAt(i - 1);
            for (int j = 1; j <= text2.length(); j++) {
                char chj = text2.charAt(j - 1);
                if (chi == chj) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);
                }
            }
        }

        return dp[text1.length()][text2.length()];
    }
}

1035.不相交的线

题目链接：力扣

思路

这道题目是求不相交的线，其实就是求两个数组的最长公共子序列，这样就跟上一道题目一样了，一模一样的代码，就是把字符串换成了数组

不相交的线

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {

        // 创建dp数组
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];

        // 初始化dp数组

        // 推导dp数组
        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;
                } else {
                    dp[i][j] = Math.max(dp[i][j-1],dp[i-1][j]);
                }
            }
        }

        return dp[nums1.length][nums2.length];
    }
}

53. 最大子序和

题目链接：力扣

思路

看起来简单，自己写了一下，还是有不少细节的，只要是初始化和result的赋值 ,如果摸不准就在推导完dp数组后在选取最大值

1、确定dp数组的含义

dp[i]：包括下标i之前的最大连续子序列和为dp[i]

2、确定递推公式

做过贪心算法的方法就很容易理解，有两种情况

dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
nums[i]，即：从头开始计算当前连续子序列和

3、初始化

从递推公式可以看出来dp[i]是依赖于dp[i - 1]的状态，dp[0]就是递推公式的基础。

dp[0]应为nums[0]即dp[0] = nums[0]

4、遍历顺序

从前向后进行遍历

最大子序列

动态规划

// 在推导dp数组的过程中获取最大值
class Solution {
    public int maxSubArray(int[] nums) {

        // 创建dp数组
        int[] dp = new int[nums.length];

        // 初始化dp数组
        dp[0] = nums[0];

        // 推导dp数组
        // 获取结果
        int result = nums[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(nums[i],dp[i - 1] + nums[i]);
            if (dp[i] > result) {
                result = dp[i];
            }
        }
        return  result;
    }
}

// 推导完dp数组后再获取最大值
class Solution {
    public int maxSubArray(int[] nums) {

        // 创建dp数组
        int[] dp = new int[nums.length];

        // 初始化dp数组
        dp[0] = nums[0];

        // 推导dp数组
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(nums[i],dp[i - 1] + nums[i]);
        }
        
        // 获取结果
        int result = Integer.MIN_VALUE;
        for (int num : dp) {
            result = num > result ? num : result;
        }
        return result;
    }
}

贪心算法

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

        int result = Integer.MIN_VALUE;
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            count += nums[i];
            if (count > result) {
                result = count;
            }
            if (count < 0) {
                count = 0;
            }
        
        }
        return result;
    }
}