代码随想录算法训练营第五十三天| 1143.最长公共子序列，1035.不相交的线，53. 最大子序和动态规划

最新推荐文章于 2024-07-24 19:35:30 发布

WDR8965

最新推荐文章于 2024-07-24 19:35:30 发布

阅读量927

点赞数 21

分类专栏：代码随想录算法训练营33期文章标签：算法数据结构 leetcode java

本文链接：https://blog.csdn.net/qq_42973684/article/details/138293993

版权

代码随想录算法训练营33期专栏收录该内容

53 篇文章 2 订阅

订阅专栏

题目与题解

1143.最长公共子序列

题目链接：1143.最长公共子序列

代码随想录题解：1143.最长公共子序列

视频讲解：动态规划子序列问题经典题目 | LeetCode：1143.最长公共子序列_哔哩哔哩_bilibili

解题思路：

一开始试图用四层循环暴力法来做，就超时了。

看完代码随想录之后的想法

这里主要是dp定义跟前面有点不一样，随之的递推公式也不一样。

dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]，所以最后得到的公共子序列不一定要包含text1[i-1]和text2[i-1]。

递推公式有两大情况： text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同

如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;

如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。

dp的第一行和第一列分别表示text1或text2和空字符串的最长公共子序列，必然初始化为0。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
		int[][] dp = new int[text1.length()+1][text2.length()+1];
		int result = 0;
		for (int i = 1; i < text1.length()+1; i++) {
			for (int j = 1; j < text2.length()+1; j++) {
				if (text1.charAt(i-1) == text2.charAt(j-1)) {
					dp[i][j] = dp[i-1][j-1]+1;
				} else {
					dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
				}
				result = Math.max(result, dp[i][j]);
			}
		}
		return result;
    }
}

遇到的困难

序列和连续序列的计算会有很多不一样，子序列要考虑的可能性更多。

1035.不相交的线

题目链接：1035.不相交的线

代码随想录题解：1035.不相交的线

视频讲解：动态规划之子序列问题，换汤不换药 | LeetCode：1035.不相交的线_哔哩哔哩_bilibili

解题思路：

没有思路看答案。

看完代码随想录之后的想法

直线不能相交，这就是说明在字符串A中找到一个与字符串B相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，链接相同数字的直线就不会相交。本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度！

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
		int[][] dp = new int[nums1.length+1][nums2.length+1];
		int result = 0;
		for (int i = 1; i < nums1.length + 1; i++) {
			for (int j = 1; j < nums2.length + 1; 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-1][j], dp[i][j-1]);
				}
				result = Math.max(result, dp[i][j]);
			}
		}
		return result;
    }
}

遇到的困难

题目翻译成最大相同子序列有点困难。

53. 最大子序和

题目链接：53. 最大子序和

代码随想录题解：53. 最大子序和

视频讲解：看起来复杂，其实是简单动态规划 | LeetCode：53.最大子序和_哔哩哔哩_bilibili

解题思路：

dp定义：对于nums[0]-nums[i]的序列，其子序列包含nums[i]时，最大子序和的值。

递推公式：因为要求的是连续序列的和，所以可以根据dp[i-1]和nums[i]推出dp[i]的值。如果dp[i-1]+nums[i] > nums[i]，说明nums[i]可以纳入dp[i-1]的子序列，dp[i]=dp[i-1]+nums[i] ，否则从nums[i]开始开启一个新的序列，dp[i]=nums[i]。

初始化dp[0]为nums[0]，从前往后遍历即可。

class Solution {
    public int maxSubArray(int[] nums) {
		if (nums.length == 1) return nums[0];
		int[] dp = new int[nums.length];
		int result = nums[0];
		dp[0] = nums[0];
		for (int i = 1; i < nums.length; i++) {
			dp[i] = Math.max(nums[i], dp[i-1] + nums[i]);
			result = Math.max(result, dp[i]);
		}
		return result;
    }
}

看完代码随想录之后的想法

因为dp的依赖关系是只有前后两个相关，所以可以简化dp的空间占用。

//因为dp[i]的递推公式只与前一个值有关，所以可以用一个变量代替dp数组，空间复杂度为O(1)
class Solution {
    public int maxSubArray(int[] nums) {
        int res = nums[0];
        int pre = nums[0];
        for(int i = 1; i < nums.length; i++) {
            pre = Math.max(pre + nums[i], nums[i]);
            res = Math.max(res, pre);
        }
        return res;
    }
}