算法日记day 42（动归之不相交的线|最大子数组和|判断子序列）

一、不相交的线

题目：

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

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

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

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

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

示例 1：

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

示例 2：

输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2]
输出：3

示例 3：

输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1]
输出：2

思路：

在经过审题之后，为了使线不相交，本题其实就转化为了最长公共子序列的问题，只不过加上了一层不可相交线的外衣，其本质与最长公共子序列并无区别

代码：

public int maxUncrossedLines(int[] nums1, int[] nums2) {
    // 获取两个数组的长度
    int n1 = nums1.length;
    int n2 = nums2.length;
    
    // 创建一个二维数组dp，dp[i][j]表示nums1前i个元素和nums2前j个元素的最长公共子序列的长度
    int[][] dp = new int[n1 + 1][n2 + 1];
    
    // 遍历dp数组填充数据
    for (int i = 1; i <= n1; i++) {
        for (int j = 1; j <= n2; j++) {
            // 如果nums1的第i-1个元素等于nums2的第j-1个元素
            if (nums1[i - 1] == nums2[j - 1]) {
                // 更新dp[i][j]，表示在dp[i-1][j-1]的基础上增加1
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                // 否则dp[i][j]取dp[i-1][j]和dp[i][j-1]的最大值
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    
    // 返回最大不相交线条的数量，即最长公共子序列的长度
    return dp[n1][n2];
}

• n1 和 n2 分别表示 nums1 和 nums2 的长度。
• 创建一个二维数组 dp，大小为 (n1 + 1) x (n2 + 1)。dp[i][j] 用于存储 nums1 的前 i 个元素和 nums2 的前 j 个元素的最长公共子序列长度。数组大小加1是为了处理边界情况（即处理空数组）。
• 外层和内层循环遍历 dp 数组，i 和 j 分别表示 nums1 和 nums2 的索引。
• 当 nums1[i - 1] 等于 nums2[j - 1] 时，dp[i][j] 更新为 dp[i - 1][j - 1] + 1，表示在 dp[i-1][j-1] 的基础上增加 1。
• 否则，dp[i][j] 取 dp[i - 1][j] 和 dp[i][j - 1] 的最大值，表示在 nums1 或 nums2 中剔除当前元素后的最长公共子序列长度。
• 返回 dp 数组中的最后一个元素 dp[n1][n2]，即 nums1 和 nums2 的最长公共子序列的长度。

二、最大子数组和 

题目：

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

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

示例 1：

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

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

思路：

首先明确dp数组的含义，本题中dp数组含义为以 i 为尾的nums[i]最大子数组和为dp[i]，定义初始结结果为第一个数的值，此后遍历数组，如果相加的值大于初始值，则更换为相加后的值，否则将初始值更替为当前遍历的值，因此递推关系式为

                                   dp[i] = max(dp[i-1] + nums[i]，dp[i])

代码：

public int maxSubArray(int[] nums) {
    // 如果输入数组为空，返回0
    if (nums.length == 0)
        return 0;

    // 创建一个dp数组用于存储到当前位置的最大子数组和
    int[] dp = new int[nums.length];
    // 初始化第一个元素的最大子数组和
    dp[0] = nums[0];
    // 初始化结果为第一个元素
    int res = nums[0];

    // 遍历数组，从第二个元素开始
    for (int i = 1; i < nums.length; i++) {
        // dp[i]表示以nums[i]结尾的最大子数组和
        // 可以选择将当前元素加到前一个子数组，或者从当前元素重新开始
        dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
        // 更新结果，保留当前最大的子数组和
        res = Math.max(res, dp[i]);
    }

    // 返回找到的最大子数组和
    return res;
}

• 首先检查输入数组是否为空。如果数组为空，直接返回 0。
• 创建一个 dp 数组，用于存储以每个元素结尾的最大子数组和。
• 将 dp[0] 初始化为 nums[0]，因为以第一个元素结尾的子数组只有它自己。
• 另外，定义一个变量 res 来存储当前找到的最大子数组和，初始值也是 nums[0]。
• 从第二个元素开始遍历数组：
  • 然后使用 res = Math.max(res, dp[i]) 更新当前的最大子数组和。
  • 使用 Math.max(dp[i - 1] + nums[i], nums[i]) 判断两种情况：
    • 第一种情况是将当前元素 nums[i] 加到之前的最大子数组和 dp[i - 1] 上；
    • 第二种情况是从当前元素 nums[i] 开始新的子数组（即忽略之前的任何元素）。
  • dp[i] 表示以 nums[i] 结尾的最大子数组和。
• 遍历完数组后，返回找到的最大子数组和 res。

三、判断子序列 

题目：

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

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

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false

动归解法 

思路：

采用动态规划的思路解决，此时的dp数组的含义为以i-1为结尾的字符串s和以j-1为结尾的字符串t的子序列长度为dp[i][j]，对于其中相同的元素，递推式为

                                                    dp[i][j] = dp[i-1][j-1] + 1

否则应该保留之前的值，子序列长度不变，因此递推式为

                                                       dp[i][j] = dp[i][j-1] 

代码：

public boolean isSubsequence(String s, String t) {
    // 获取字符串 s 和 t 的长度
    int len1 = s.length();
    int len2 = t.length();

    // 创建一个二维数组 dp，dp[i][j] 代表 s 的前 i 个字符是否是 t 的前 j 个字符的子序列
    int[][] dp = new int[len1 + 1][len2 + 1];

    // 填充 dp 数组
    for (int i = 1; i <= len1; i++) { // 遍历 s 的每个字符
        for (int j = 1; j <= len2; j++) { // 遍历 t 的每个字符
            if (s.charAt(i - 1) == t.charAt(j - 1)) { // 如果 s 的当前字符等于 t 的当前字符
                dp[i][j] = dp[i - 1][j - 1] + 1; // s 的前 i 个字符中的第 i 个字符匹配上了 t 的第 j 个字符
            } else {
                dp[i][j] = dp[i][j - 1]; // 否则，当前字符不匹配，保留之前的值
            }
        }
    }

    // 最终检查是否 s 的所有字符都是 t 的子序列中的字符
    return dp[len1][len2] == len1; // 如果 dp[len1][len2] 等于 len1，说明 s 是 t 的子序列
}

1. • len1 和 len2 分别表示字符串 s 和 t 的长度。
   • dp 是一个二维数组，其中 dp[i][j] 代表 s 的前 i 个字符是否可以在 t 的前 j 个字符中找到作为子序列。

2. 动态规划填表：

   • 外层循环遍历 s 的每个字符（从 i = 1 到 len1），内层循环遍历 t 的每个字符（从 j = 1 到 len2）。
   • 如果 s 的第 i 个字符（s.charAt(i - 1)）等于 t 的第 j 个字符（t.charAt(j - 1)），则 dp[i][j] 的值等于 dp[i - 1][j - 1] + 1。这表示如果前 i-1 个字符是 t 的前 j-1 个字符的子序列，那么当前字符也匹配，子序列的长度增加了 1。
   • 如果当前字符不匹配，则 dp[i][j] 等于 dp[i][j - 1]，表示子序列长度不变，继续保持之前的值。

3. 判断结果：

   • 最后返回 dp[len1][len2] == len1，检查 s 是否能在 t 的全部字符中作为子序列。如果 dp[len1][len2] 的值等于 len1，说明所有的字符都找到了匹配，s 是 t 的子序列。

双指针解法 

public boolean isSubsequence(String s, String t) {
    // 获取字符串 s 和 t 的长度
    int n1 = s.length();
    int n2 = t.length();

    // 将字符串 s 和 t 转换为字符数组
    char[] s1 = s.toCharArray();
    char[] t1 = t.toCharArray();

    // 初始化两个指针 i 和 j，用于遍历 s 和 t
    int i = 0, j = 0;

    // 使用 while 循环同时遍历 s 和 t，直到其中一个字符串被遍历完
    while (i < n1 && j < n2) {
        // 如果 s 的当前字符与 t 的当前字符相等
        if (s1[i] == t1[j]) {
            i++; // 移动 s 的指针到下一个字符
        }
        j++; // 始终移动 t 的指针到下一个字符
    }

    // 如果 i 等于 n1，说明 s 的所有字符都在 t 中找到了匹配
    return i == n1;
}

1. 获取长度：

   • int n1 = s.length();：获取字符串 s 的长度。
   • int n2 = t.length();：获取字符串 t 的长度。

2. 转换为字符数组：

   • char[] s1 = s.toCharArray();：将字符串 s 转换为字符数组 s1。
   • char[] t1 = t.toCharArray();：将字符串 t 转换为字符数组 t1。

3. 初始化指针：

   • int i = 0, j = 0;：初始化两个指针 i 和 j，分别用来跟踪 s 和 t 中当前的字符位置。i 用于指向 s 的字符，j 用于指向 t 的字符。

4. 遍历字符串：

   • while (i < n1 && j < n2)：当 i 小于 n1 且 j 小于 n2 时，继续执行循环，这意味着仍然有字符未被检查。
   • 在循环中，首先检查 s 和 t 当前指针所指的字符是否相等：
     • if (s1[i] == t1[j])：如果 s 的当前字符与 t 的当前字符相等，则说明找到了一个匹配。
       • i++;：移动 i 指针到下一个字符，以便检查 s 中的下一个字符。
     • j++;：无论字符是否匹配，都将 j 指针移动到 t 中的下一个字符，继续遍历 t。

5. 结果判断：

   • return i == n1;：循环结束后，检查 i 是否等于 n1。如果相等，说明字符串 s 中的所有字符都在 t 中找到了匹配，返回 true；否则返回 false。

今天的学习就到这里