代码随想录算法训练营第四十三天 | 找公共的子序列 | 392.判断子序列（编辑距离）| 115.不同的子序列（困难）

Day 43 总结

• 自己实现中遇到哪些困难
  • 1035.不相交的线: 最长公共子序列
  • 53. 最大子序和：子数组的最大和
  • 392.判断子序列
    • 字符串s， 是否出现在字符串t中，判断他们子序列
    • 怎么想到的去找两个字符串中的公共子序列。
  • 115.不同的子序列
    • s 的子序列， 满足 t 的个数。
• 今日收获，记录一下自己的学习时间
  • 20:45 - 22:15

1035.不相交的线

题目链接：1035. 不相交的线 - 力扣（LeetCode）

题目描述：

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

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

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

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

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

实现思路：

给两个数组， 数组1和数组2， 判断能在数组1中找到多少个数组2的子序列。求两个字符串的最长公共子序列的长度！

随便在nums1中选长度，能在nums2中找到n个子序列(最大子序列长度为 n)。那么再增加一个长度，能找到多少个子序列(最大子序列长度为几)呢？

先看 3 在 25125中的匹配情况，再看35， 35在25中匹配一段，在251中一段，25125中 5和最新的5匹配上了， 所以查看一下3匹配的是多长，再加上它。

_ 2 5 1 2 5 nums2
_ 0 0 0 0 0
3 0 0 0 0 0
5 0 1 1 1 1
2 1 1 1 2 2
1 1 1 2 2 2
5 1 2 2 2 3

代码实现：

class Solution {
    public int maxUncrossedLines(int[] nums1, int[] nums2) {
       int n1 = nums1.length;
       int n2 = nums2.length;

       int[][] dp = new int[n1+1][n2+1];

       for (int i=1; i<=n1; i++) {
            for (int j=1; j<=n2; 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[n1][n2];
    }
}

53. 最大子序和

题目链接：53. 最大子数组和 - 力扣（LeetCode）

题目描述：

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

实现思路：

子数组是连续的，只要和不为负数，这个子数组就可以可以信赖的，可以继续扩展的。更新最大值即可。

站在动态规划的角度，当前数字需要记录一个当前数组的最大值， dp[i] = max(dp[i - 1] + nums[i], nums[i]); 记录更新过程中的最大值。

代码实现：

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

        return result;
    }
}

392.判断子序列（编辑距离入门）

题目链接：392. 判断子序列 - 力扣（LeetCode）

题目描述：

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

实现思路：

判断字符串1会不会出现在字符串2中， 双指针。

编辑距离：题意中我们也可以发现，只需要计算删除的情况，不用考虑增加和替换的情况。能够通过一定的操作次数，变成原来的字符串。

dp数组：dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

我的问题

怎么想到的去找两个字符串中的公共子序列。

代码实现：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int length1 = s.length(); int length2 = t.length();
        int[][] dp = new int[length1+1][length2+1];
        for(int i = 1; i <= length1; i++){
            for(int j = 1; j <= length2; j++){
                if(s.charAt(i-1) == t.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    dp[i][j] = dp[i][j-1];
                }
            }
        }
        if(dp[length1][length2] == length1){
            return true;
        }else{
            return false;
        }
    }
}

// 判断s当中需要多少步删除操作
class Solution {
    public boolean isSubsequence(String s, String t) {
        int length1 = s.length(); 
        int length2 = t.length();
        int[][] dp = new int[length1+1][length2+1];
        for (int i=0; i<=length1; i++) dp[i][0] = i;
        for (int i=0; i<=length1; i++) dp[0][i] = i;

        for(int i = 1; i <= length1; i++){
            for(int j = 1; j <= length2; j++){
                if(s.charAt(i-1) == t.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = dp[i][j-1] + 1;
                }
            }
        }
        return length2 - dp[length1][length2] == length1;
    }
}

115.不同的子序列

题目链接：

题目描述：

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。

输入：s = "rabbbit", t = "rabbit"输出：3解释：
如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案rabbbitrabbbitrabbbit

实现思路：

dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

一段子序列，在另一端子序列中出现的次数。

r 在 rabbbit中出现次数

ra在rabbbit出现次数

rabb在rabbbit出现次数

一个子序列在另一个子序列中出现的次数取决于什么呢？如果子序列t的最后一位，匹配不上，用子序列t的上一次匹配结果。

代码实现：

class Solution {
    public int numDistinct(String s, String t) {
        int n1 = s.length();
        int n2 = t.length();

        int[][] dp = new int[n1+1][n2+1];
        for (int i=0; i<=n1; i++) {dp[i][0] = 1;}

        for (int i=1; i<=n1; i++) {
            for (int j=1; j<=n2; j++) {
                if (s.charAt(i-1) == t.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                }
                else {
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[n1][n2];
    }
}