算法练习Day53|1143.最长公共子序列 ● 1035.不相交的线 ● 53. 最大子序和 动态规划

LeetCode:1143.最长公共子序列

1143. 最长公共子序列 - 力扣（LeetCode）

1.思路

两个字符串最大相等字符序列的值可以以二维数组的形式展示出来，从左上角向右下角进行铺设，数值逐渐变大。

2.代码实现

 1class Solution {
 2    public int longestCommonSubsequence(String text1, String text2) {
 3        char[] char1 = text1.toCharArray(); // 字符串转字符数组
 4        char[] char2 = text2.toCharArray(); // 同上
 5        int[][] dp = new int[text1.length() + 1][text2.length() + 1]; // 二维dp[][]数组
 6
 7        for (int i = 1; i < text1.length() + 1; i++) { // 遍历到最后一位要加1，text1.length() + 1
 8            for (int j = 1; j < text2.length() + 1; j++) { // 同上
 9                if (char1[i - 1] == char2[j - 1]) { // 字符比较
10                    dp[i][j] = dp[i - 1][j - 1] + 1; // 前一字符各自相等时的状态
11                } else {
12                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); // 前一状态不统一时的状态推导
13                }
14            }
15        }
16        return dp[text1.length()][text2.length()]; // 返回最后的结果
17    }
18}

3.复杂度分析

时间复杂度：O(n * m).
空间复杂度：O(n).

LeetCode:1035.不相交的线

1035. 不相交的线 - 力扣（LeetCode）

1.思路

本题容易被交叉的线所迷惑，导致陷入什么时间应该选择那个数才能保证线的数量最大。卡哥一语道破本题的本质：最长公共子序列的值即为本体题解，解法同上。

2.代码实现

 1class Solution {
 2    public int maxUncrossedLines(int[] nums1, int[] nums2) {
 3        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
 4        for (int i = 1; i < nums1.length + 1; i++) {
 5            for (int j = 1; j < nums2.length + 1; j++) {
 6                if (nums1[i - 1] == nums2[j - 1]) {
 7                    dp[i][j] = dp[i - 1][j - 1] + 1;
 8                } else {
 9                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
10                }
11            }
12        }
13        return dp[nums1.length][nums2.length];
14    }
15}
16

3.复杂度分析

时间复杂度：O(n * m).
空间复杂度：O(n).

LeetCode:53. 最大子序和

53. 最大子数组和 - 力扣（LeetCode）

1.思路

一位数组推导即可，当前节点的连续子数组最大和为当前节点值和前一节点最大子数组+当前节点值的较大值。

2.代码实现

 1class Solution {
 2    public int maxSubArray(int[] nums) {
 3        int[] dp = new int[nums.length];
 4        dp[0] = nums[0];
 5        int res = nums[0];
 6        for (int i = 1; i < nums.length; i++) {
 7            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
 8            res = Math.max(res, dp[i]);
 9        }
10
11        return res;
12    }
13}
14
15// 自带推导
16class Solution {
17    public int maxSubArray(int[] nums) {
18        int res = nums[0];
19        int pre = nums[0];
20        for (int i = 1; i < nums.length; i++) {
21            pre = Math.max(pre + nums[i], nums[i]); // 当前节点值 与 当前节点值与之前的节点值的最大值 的比较（自带递归推导感）
22            res = Math.max(pre, res); // 结果值 在当前结果值和后序结果值之间
23        }
24        return res;
25    }
26}

3.复杂度分析

时间复杂度：O(n).
空间复杂度：O(n).