代码随想录Day_53打卡

①、最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

事例：

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace" ，它的长度为 3 。

思路：

        使用动态规划，跟最长重复子数组类似，由左上角推导而来。由于这道题不用求连续子序列，但两层for循环都是字符串从左往右遍历；在dp上看，只有两种情况，若字符相等，则dp[i][j] = dp[i - 1][j - 1] + 1，若不等，则继承左边或上面的最大值，这样dp最后一个数就是最长公共子序列的个数。

动态规划：

        dp定义及含义：dp[i][j]表示text1前i个字符与text2前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])

        初始化：第一行和第一列为0

        遍历顺序：保证两个字符串从左往右遍历，嵌套即可。

        dp[text1.length()][text2.length()]即为答案。

代码：

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

②、不相交的线

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。

现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足满足：

•  nums1[i] == nums2[j]
• 且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。

以这种方法绘制线条，并返回可以绘制的最大连线数。

事例：

输入：nums1 = [1,4,2], nums2 = [1,2,4]
输出：2
解释：可以画出两条不交叉的线，如上图所示。 
但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。

思路：

        由上图可看出，最大连线数其实就是最长公共子序列；因为每条线意味着两数相等(公共)，而不相交则表明每条线都是从左往右不跨度的，保证了相对次序。其实就是上题的变形，代码完全一致。

代码：

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

③、最大子数组合

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

事例：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

思路：

        使用动态规划，创建一维数组dp，dp[i]表示nums到i时的最大子数和，故dp也是从左往右推导，而nums下标i的最大子数可由两个选择：采纳前i - 1个的最大子数和或者不采纳，即dp[i] = Math.max(dp[i - 1] + nums[i],nums[i])，记录dp中的最大值，最终返回即可。

动态规划：

        dp定义及含义：dp[i]表示nums到i时的最大子数和

        状态转移方程：dp[i] = Math.max(dp[i - 1] + nums[i],nums[i])

        初始化：dp[0] = nums[0]

        遍历顺序：数组从左往右遍历

        dp中的最大值即为答案

代码：

public int maxSubArray(int[] nums) {
        //动态规划
        if(nums.length == 1) return nums[0];
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = nums[0];
        int res = dp[0];
        for(int i = 1;i < nums.length;i++){
            dp[i] = Math.max(dp[i - 1] + nums[i],nums[i]);
            if(dp[i] > res) res = dp[i];
        }
        return res;

        //贪心算法
        int count = 0;
        int res = Integer.MIN_VALUE;
        for(int i = 0;i < nums.length;i++){
            count += nums[i];
            if(count > res) res = count;
            if(count < 0) count = 0;
        }
        return res;
    }

参考：代码随想录 (programmercarl.com)