体会一下本题和 718. 最长重复子数组 的区别
视频讲解:https://www.bilibili.com/video/BV1ye4y1L7CQ
https://programmercarl.com/1143.%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%AD%90%E5%BA%8F%E5%88%97.html
这道题就是最长重复子序列的不连续版本了,那道题里我特意明确了一下,重复一定是连续的。
那这道题就不仅仅是dp[i-1][j-1] + 1了,而是找到0~i-1 ,j-1 最大那个了。
这个区别就像最长子序列和最长连续子序列。
我试试
写是写出来了,但是图里的例子就会出现重复的情况:
我的代码是:
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
//dp
int[][] dp = new int[text2.length() + 1][text1.length() + 1];
int result = 0;
//init
//func
for (int j = 1; j < text1.length() + 1; j++) {
for (int i = 1; i < text2.length() + 1; i++) {
if (text1.charAt(j - 1) == text2.charAt(i - 1)) {
//找前几行
for (int m = 0; m < i; m++) {
for (int n = 1; n <= j; n++) {
dp[i][j] = Math.max(dp[i][j], dp[m][n] + 1);
result = Math.max(result, dp[i][j]);
}
}
//找这一行
for (int n = 0; n < j; n++) {
dp[i][j] = Math.max(dp[i][j], dp[i][n]);
result = Math.max(result, dp[i][j]);
}
}
}
}
for(int i = 0; i < text2.length() + 1; i++) {
for (int j = 0; j < text1.length() + 1; j++) {
System.out.print(dp[i][j] + " ");
}
System.out.println();
}
return result;
}
}
感觉不能找之前的最大的那个,比如这个c,在dp[3][3]赋值一次变成3之后,又在dp[5][4] 变成 4了,但其实它只应该操作一次。
也就是text1拿来的元素(外层for循环的元素),每次放到text 2 里去遍历一遍,找有没有自己,有的话就要变长。
但是只能找一个自己,因为拿来的一个元素,最多变长一次,也就是+1,不能在for循环中 +1 两次。
//func
for (int j = 1; j < text1.length() + 1; j++) {
for (int i = 1; i < text2.length() + 1; i++) {
if (text1.charAt(j - 1) == text2.charAt(i - 1)) {
//找前几行
for (int m = 0; m < i; m++) {
for (int n = 1; n <= j; n++) {
dp[i][j] = Math.max(dp[i][j], dp[m][n] + 1);
result = Math.max(result, dp[i][j]);
}
}
//找这一行
for (int n = 0; n < j; n++) {
dp[i][j] = Math.max(dp[i][j], dp[i][n] + 1);
result = Math.max(result, dp[i][j]);
}
break;
}
}
}
这一部分加上break也是错的。如果再text2里找到了这个元素,并且变长结束了,就结束这个元素。去text1里找下一个。
那我直接看题解吧
我的思路是不太正确的。
最长递增子序列是,每次都从0看到i-1,如果 i 比 j 大,就尝试更新dp[i] 。
而这道题不太一样,我们要记住dp数组的含义。
长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
所以不会出现dp[i][j] 中间 全是 0 的情况。 比如 1 2 5 和 1 2 7 8
到 2 那里长度是2,到5 和 7 那里长度不该是0,而还是 2.才对
所以要对两个元素不相等的情况赋值,这样两个元素相等的时候,也不需要去找最大的那个长度再 +1 了,可以直接dp[i-1][j-1] + 1。
因为不管前一个是不是相同的,都被赋值了,是相同的就是到 2 那里的长度2.
不是相同的就是, 5 和 7 那里的长度 2.
再有另一个需要注意的就是怎么给不相同的时候赋值。比如 a c b 和 a b e f
I到b,j到e的时候不相同了,按理来说应该返回 长度2,因为ab 和ab是相同的。
但是呢如果你看dp[i-1][j] 是 ac和 abe = 1,dp[i][j-1] 是acb和ab = 2.
所以每次应该取这两个更大的一个。也就是虽然我拿你俩不相同,不能让长度 + 1. 但是这个情况的最长长度,可能是 i 的更长,也可能是 j 的更长。
思路清晰就不难
感觉子序列问题真的好难。
我没法举一反三啊
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
//dp
int[][] dp = new int[text1.length() + 1][text2.length() + 1];
int result = 0;
//init
//func
//一行一行的去更新
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;
result = Math.max(result, dp[i][j]);
} else {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return result;
}
}
其实本题和 1143.最长公共子序列 是一模一样的,大家尝试自己做一做。
视频讲解:https://www.bilibili.com/video/BV1h84y1x7MP
https://programmercarl.com/1035.%E4%B8%8D%E7%9B%B8%E4%BA%A4%E7%9A%84%E7%BA%BF.html
我有点想不出来,怎么表示这个线呢。
啊!只有相同元素才会连线,但可能相交。
只有公共子序列,排成了一样的顺序,就不会相交了。
也就是找最大公共子序列。
悟出来这个,就不用做了,直接改改上一道题的代码了
class Solution {
public int maxUncrossedLines(int[] nums1, int[] nums2) {
//dp
int[][] dp = new int[nums1.length + 1][nums2.length + 1];
int result = 0;
//init
//func
//一行一行的去更新
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;
result = Math.max(result, dp[i][j]);
} else {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return result;
}
}
这道题我们用贪心做过,这次 再用dp来做一遍
视频讲解:https://www.bilibili.com/video/BV19V4y1F7b5
https://programmercarl.com/0053.%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%92%8C%EF%BC%88%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%EF%BC%89.html
说之前拿贪心做过,我都快忘了。啊,是看sum的效果是buff还是debuff,debuff就重新开始选。
dp的话 我试试先。
我做出来了!!!
以 i 为结尾的连续子数组de最大和是dp[i] 。
每次比较 是只有自己更大呢?还是自己 + dp[i-1] 更大呢?
其实也就是,dp[i-1] 放的是之前的最大和,如果这个最大和+nums[i] 和nums[i] 相比是debuff(其实也就是 最大和 < 0 就是debuff),那完全可以从nums[i]开始了,没必要要前面的了。
//如果是debuff,那么就重新开始吧
if (dp[i - 1] < 0) {
dp[i] = nums[i];
} else {
dp[i] = dp[i - 1] + nums[i];
}
dp[0] = nums[0]
正序
result 初始化应该是nums[0]
我太厉害了
class Solution {
public int maxSubArray(int[] nums) {
//dp
int[] dp = new int[nums.length];
int result = nums[0];
//init
dp[0] = nums[0];
//func
for (int i = 1; i < dp.length; i++) {
//如果是debuff,那么就重新开始吧
if (dp[i - 1] < 0) {
dp[i] = nums[i];
} else {
dp[i] = dp[i - 1] + nums[i];
}
result = Math.max(result, dp[i]);
}
return result;
}
}