动态规划子序列问题经典题目 | LeetCode:1143.最长公共子序列_哔哩哔哩_bilibili
1143.最长公共子序列
思路:在递推方程与求公共数组的几乎类似,但是不同的是本题要求的公共序列不需要元素的连续,所以当s[i]!=t[j]时,需要继承前一转态中的公共序列最大值。
// 时间复杂度O(n*m)
// 空间复杂度O(n*m)
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
int n = text1.length();
int m = text2.length();
char[] t1 = text1.toCharArray();
char[] t2 = text2.toCharArray();
// dp数组的含义是在text1下标i与text2下标j之前数组的公共子序列长度为dp[i][j]
int[][] dp = new int[n+1][m+1];
// 遍历顺序,从前往后
// for(int i=1; i<=n; i++){
// for(int j=1; j<=m; j++){
// if(t1[i-1] == t2[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]); // 关键在于此,这是区别公共数组,且数组元素连续的关键不同之处
// }
// }
// return dp[n][m];
// 遍历顺序,从后往前
for(int i=n-1; i>=0; i--){
for(int j=m-1; j>=0; j--){
if(t1[i] == t2[j])
dp[i][j] = dp[i+1][j+1]+1;
else
dp[i][j] = Math.max(dp[i+1][j], dp[i][j+1]);
}
}
return dp[0][0];
}
}
1035.不相交的线
思路:直线不能相交,这就是说明在字符串A中 找到一个与字符串B相同的子序列,且这个子序列不能改变相对顺序,只要相对顺序不改变,链接相同数字的直线就不会相交。
拿示例一A = [1,4,2], B = [1,2,4]为例,其实也就是说A和B的最长公共子序列是[1,4],长度为2。 这个公共子序列指的是相对顺序不变(即数字4在字符串A中数字1的后面,那么数字4也应该在字符串B数字1的后面)
这么分析完之后,大家可以发现:本题说是求绘制的最大连线数,其实就是求两个字符串的最长公共子序列的长度!(代码随想录)
// 时间复杂度O(n*m)
// 空间复杂度O(n*m)
class Solution {
public int maxUncrossedLines(int[] nums1, int[] nums2) {
int n = nums1.length;
int m = nums2.length;
int max = 0;
int[][] dp = new int[n+1][m+1];
for(int i=1; i<=n; i++){
for(int j=1; j<=m; j++){
if(nums1[i-1] == nums2[j-1])
dp[i][j] = dp[i-1][j-1]+1;
else // 相较于前一题dp直接赋值为零,此处在不相等时还需要更新是因为所求的公共子序列是不连续的
dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
max = Math.max(dp[i][j], max);
}
}
return max;
}
}
53. 最大子序和
思路:贪心和动归都可以求解,注意负数是转移的关键。
// 时间复杂度O(n)
// 空间复杂度O(1)
class Solution {
public int maxSubArray(int[] nums) {
// // 贪心的思想就是每一步都需要使我的数组和变大一点
// if(nums.length == 1)
// return nums[0];
// int max = nums[0];
// int sum = nums[0];
// int i=1;
// while(i<nums.length){
// // 特殊情况出现一段连续的负数,此时直接跳过
// if(sum<0 && nums[i]<0){
// if(sum < nums[i])
// sum = nums[i];
// }
// else
// sum = Math.max(sum+nums[i], nums[i]);
// i++;
// max = sum>max? sum:max;
// }
// 时间复杂度O(n)
// 空间复杂度O(n)
// 使用动态规划进行求解
int max = Integer.MIN_VALUE;
int[] dp = new int[nums.length+1];
for(int i=1; i<=nums.length; i++){
// 是继续延续当前数组,然后选择新的元素开始
dp[i] = Math.max(dp[i-1]+nums[i-1], nums[i-1]);
max = Math.max(dp[i], max);
}
return max;
}
}