day53｜● 1143.最长公共子序列 ● 1035.不相交的线 ● 53. 最大子序和

最长重复子数组

Input: nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
Output: 3
Explanation: The repeated subarray with maximum length is [3,2,1].

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）

注意这里i，j遍历从1开始，这是为了方便i=0，j=0的out of index之后情况处理会比较麻烦

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length+1][nums2.length+1];
        int maxLength = 0;
        for (int i = 1; i <= nums1.length; i++) {
            for (int j = 1; j <= nums2.length; j++) {
                if (nums1[i-1] == nums2[j-1]) {
                    dp[i][j] = dp[i-1][j-1]+1;
                    maxLength = Math.max(dp[i][j], maxLength);
                }
            }
        }
        return maxLength;
    }
}

时间复杂度：O(n × m)，n 为A长度，m为B长度
空间复杂度：O(n × m)

1143.最长公共子序列

Input: text1 = “abcde”, text2 = “ace”
Output: 3
Explanation: The longest common subsequence is “ace” and its length is 3.

经典题，记背！！！！！

1. 注意从1开始遍历
2. dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列长度为dp[i][j]
3. i-1和j-1相同，找到公共元素（abcd e和ac e）
4. i-1和j-1不相同 ，如abc d和ac e，就找（abcd和ac）与（abc和ace）的最大值，考虑新添加的元素会不会与其他的元素相同从而增加最大长度。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp = new int[text1.length()+1][text2.length()+1];
        
        for (int i = 1; i <= text1.length(); i++) {
            for (int j = 1; j <= text2.length(); 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]);
                }
            }
        }
        return dp[text1.length()][text2.length()];
    }
}

时间复杂度: O(n * m)，其中 n 和 m 分别为 text1 和 text2 的长度
空间复杂度: O(n * m)

1035.不相交的线

Input: nums1 = [1,4,2], nums2 = [1,2,4]
Output: 2
Explanation: We can draw 2 uncrossed lines as in the diagram.
We cannot draw 3 uncrossed lines, because the line from nums1[1] = 4 to nums2[2] = 4 will intersect the line from nums1[2]=2 to nums2[1]=2.

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

53. 最大子序和

dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。

dp[i]：1. 之前的值为正，是可以增加子序和的。
2. 之前的为负，没有当前值本身直接算大。

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

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

贪心算法
差点又忘了。看贪心到底贪的是什么，贪最大的和，就是一旦有和为负，会拖累总和，就赶快丢掉之前的sum

局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。
全局最优：局部最优时，记录下最大的连续和，选取最大“连续和”

class Solution {
    public int maxSubArray(int[] nums) {
        int result = Integer.MIN_VALUE;
        int sum = 0; 
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            result = result > sum ? result : sum;
            if (sum < 0) { // 注意这步在比较得出res之后，只会对下一轮res有影响
                sum = 0;
            }
        }
        return result;
    }
}

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