题目与题解
1143.最长公共子序列
题目链接：1143.最长公共子序列
代码随想录题解：1143.最长公共子序列
解题思路：
一开始试图用四层循环暴力法来做，就超时了。
看完代码随想录之后的想法
这里主要是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.不相交的线
解题思路：
没有思路看答案。
看完代码随想录之后的想法
直线不能相交，这就是说明在字符串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. 最大子序和
解题思路：
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;
}
}遇到的困难
一开始result没有初始化为dp[0]，而是初始化为Interger.MIN_VALUE，导致数组只有一个数字时返回的结果不对，还是要维持一下result的定义，提前初始化为dp[0]才对。
今日收获
dp真是千变万化，思路需要非常清晰了。子序列的题目有点难。
