代码随想录题解 Day 57 | 最长重复子数组 No.718 | 最长公共子序列 No.1143 | 不相交的线 No.1035 | 最大子数组和 No.53

最新推荐文章于 2024-09-20 20:25:15 发布

*Soo_Young*

最新推荐文章于 2024-09-20 20:25:15 发布

阅读量629

点赞数 21

分类专栏：代码随想录文章标签：动态规划笔记算法 java 学习

本文链接：https://blog.csdn.net/weixin_74895237/article/details/137019884

版权

代码随想录专栏收录该内容

44 篇文章 4 订阅

订阅专栏

文章目录

- Day 57

Day 57

01. 最长重复子数组（No. 718）

题目链接

代码随想录题解

<1> 题目

给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

提示：

1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 100

<2> 笔记

昨天时间比较紧张没有研究这道题的动态规划的解法，这里补一下。

1. 状态

本题动态规划的难点就是找不到一个可以转移的状态。有了前面动态规划问题的经验，对于一组数据最容易想到的状态就是选取的元素的范围。状态就是这个范围内最长的重复子数组的长度。

但是本体中要求的子数组是 连续的 序列，所以状态的设计必须要和结尾有关系，某个以 nums[x] 和 nums2[y] 为结尾的子数组需要通过以 nums[x - 1] 和 nums2[i - 1] 为结尾状态推出。

2. dp 数组

令 dp[i][j] 为以 nums1[i - 1] 和 nums2[j - 1] 为结尾的数组的最长的连续子序列的长度（子序列必须是 nums1[i - 1] 和 nums2[j - 1] 结尾的）。

首先来解释为什么是以这两个数为结尾的数组，因为题目中要求的是连续的子序列，所以后一个的状态仅能由以它们的 前一个元素 为结尾的数组状态推出。
为什么要选取 dp[i][j] 为 nums[i - 1] 和 nums[j - 1] 为结尾呢？这主要是为了初始化的时候比较简单，在后面递推公式的时候可以发现，dp[i][j] 的推导依赖着 dp[i - 1][j - ]的值，所以要像背包问题那样将第一行和第一列的值初始化，但是如果前移一位，那第一行就是 nums1[-1] 与 nums2 重复子数组，列同理，这两个值均是没有意义的，都可以初始化为 0。
关于不前移的方法在后面会提到

3. 递推公式

如果 nums[i - 1] != nums[j - 1]，就说明以 nums[i - 1] 和 nums[j - 1] 结尾的数组的公共子串的长度是不存在的，即赋值为 0。

而如果 nums[i - 1] == nums[j - 1] 说明它可以作为子序列的结尾，那就去寻找上一个结尾看看接上之后的值为多少：dp[i][j] = dp[i - 1][j - 1] + 1 上一个结尾的值就存储在 dp[i - 1][j - 1] 的位置上。

因为本题中的 dp 数组的设计和结尾有关，所以不确定最终需要的结果存储在以什么为结尾的状态中，所以需要在循环中不断去更新结果。

4. 初始化

以为递推公式的缘故，本体中所有的初始化的目的都是填充第一行和第一列。

对于前移一位的方式来说，将第一行和第一列均初始化为 0 即可，因为 dp[0][j] 的含义是以 nums1[-1] 与 nums2[j] 为结尾的公共子序列的长度，而这些肯定为 0。

但如果是没有前移的方式来说，就要手动对这两行进行初始化了，不过方法也很简单：

        for (int i = 0; i < nums2.length; i++) {
            if (nums2[i] == nums1[0])  {
                dp[0][i] = 1; 
                res = 1;
            }
        }
        for (int i = 0; i < nums1.length; i++) {
            if (nums1[i] == nums2[0]) {
                dp[i][0] = 1;
                res = 1;
            } 
        }

因为只有一个元素，所以最大的结果就是 1，只需要查找另一个数组中是否含有这个元素即可。

nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]

比如上面的这个输出，dp[0][j] 仅在 j == 3 时取得 1，而 dp[i][0] 也是在 i == 3 的时候取得 1，时刻记住 dp 数组的含义就可以比较轻松的写出。

<3> 代码

不后移的版本

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

后移版本

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int res1 = getRes(nums1, nums2);
        int res2 = getRes(nums2, nums1);
        return Math.max(res1, res2);
    }
    public int getRes(int[] nums1, int[] nums2) {
        int res = 0;
        int temp = 0;
        for (int i = 0; i < nums1.length; i++) {
            int k = i;
            for (int j = 0; j < nums1.length - i && j < nums2.length; j++) {
                if (nums1[k++] == nums2[j]) {
                    temp++;
                    res = Math.max(temp, res);
                } else {
                    res = Math.max(temp, res);
                    temp = 0;
                }
            }
            temp = 0;
        }
        return res;
    }
}

02. 最长公共子序列（No. 1143）

题目链接

代码随想录题解

<1> 题目

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

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

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

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

示例 1：

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

示例 2：

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

示例 3：

输入：text1 = “abc”, text2 = “def”
输出：0
解释：两个字符串没有公共子序列，返回 0

提示：

1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。

<2> 笔记

1. 状态

本题和上一题不同的是，本题中的公共子序列可以 不是连续的。

所以说本题的状态不是依赖结尾，而是依赖于长度了，即当前 i 长度的字符串 A 和 j 长度的字符串 B 的最长公共子序列。

那这个状态能否转移呢？和上个题的转移思路相同

如果 text1.charAt(i) == text2.charAt(j)，那此时的长度就是 i - 1 的字符串和 j - 1 的字符串的最长公共子序列再 加上一。
而对于不相等的情况，因为不再要求顺序，所以此时不会为 0，由前面的状态取一个最大值
- i - 1 和 j 的最大公共子序列
- i 和 j - 1 的最大公共子序列
- i - 1 和 j - 1 的最大公共子序列
因为第三种情况被前两种包括了，所以实际只需要取前面两种情况的最小值即可。

2. dp 数组

dp 数组的定义和前面相同，也分为后移和不后移的情况。

后移的情况：dp[i][j] 就是长度为 i - 1 的字符串 text1 和长度为 j - 1 的字符串 text2 的最大公共子序列

不后移的情况：dp[i][j] 就是长度为 i 的字符串 text1 和长度为 j 的字符串 text2 的最大公共子序列

3. 状态转移方程

这里讨论后移的情况，不后移的情况与这个完全相同，只是在初始化的时候要注意一下。

当 text1[i] == text2[j] 的时候

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

即在前一个状态后加一。

对于不同的情况

dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);

4. 初始化

与上题相同，只需要初始化第一行和第一列即可：

对于后移的情况，全部初始化为 0 即可，和上题相同，第一行和第一列均没有意义

对于不后移的情况，本题就变为了长度为 1 字符串和另一个字符串的最大公共子序列：

boolean temp1 = false;        
for (int i = 0; i < c2.length; i++) {
    if (c1[0] == c2[i]) {
        temp1 = true;
    }
    if (temp1) {
        dp[0][i] = 1;
    }
}
temp1 = false; // 复用
for (int i = 0; i < c1.length; i++) {
    if (c1[i] == c2[0]) {
        temp1 = true;
    }
    if (temp1) {
        dp[i][0] = 1;
    }
}

因为是长度为 1 的字符串和另一个字符串的公共子序列，所以最大值为 1，当找到第一个相等的字符后，后面的全部初始化为 1 即可。

<3> 代码

不后移

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        char[] c1 = text1.toCharArray();
        char[] c2 = text2.toCharArray();
        int[][] dp = new int[c1.length][c2.length];
        boolean temp1 = false;
        for (int i = 0; i < c2.length; i++) {
            if (c1[0] == c2[i]) {
                temp1 = true;
            }
            if (temp1) {
                dp[0][i] = 1;
            }
        }
        temp1 = false; // 复用
        for (int i = 0; i < c1.length; i++) {
            if (c1[i] == c2[0]) {
                temp1 = true;
            }
            if (temp1) {
                dp[i][0] = 1;
            }
        }
        for (int i = 1; i < dp.length; i++) {
            for (int j = 1; j < dp[0].length; j++) {
                if (c1[i] == c2[j]) 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[c1.length - 1][c2.length - 1];
    }
}

后移

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

03. 不相交的线（No. 1035）

题目链接

代码随想录题解

<1> 题目

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

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

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

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

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

示例 1：

![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/e33051eb3dbd43efa5f959902a30f05c.png)

输入：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

提示：

1 <= nums1.length, nums2.length <= 500
1 <= nums1[i], nums2[j] <= 2000

<2> 题解

1. 状态

当两个节点连接起来后，因为连线之间不能相交的性质，可以取得的部分就发生了转变。

在这里插入图片描述

比如说上图，当两个节点连接起来之后，可以选取的范围就变成了红色的部分，红色部分的状态是由蓝色部分的推导出来的。

题目中问的是最多的连线是数目是多少，而且同时要考虑到记录当前范围，所以本题中的状态就是长度为 i 的数组1 和长度为 j 的数组2 它们的最大连线数目是多少。

再来思考这个状态能否转移呢？比如上面的图片nums1[2] == nums[2]，那它们之间就可以形成连线，最优解则依赖于下图中粉色的部分，在粉色部分连线数量最大的情况上加一就是这个节点的最优解。

如果不相等的话，回顾一下状态：长度为 i 的数组 1 和长度为 j 的数组 2 它们的最大连线数目是多少。

那此时的值就是长度为 i - 1 和长度为 j 的最大连线数目，以及长度为 i 和长度为 j - 1 的最大连线数目，还有就是 i - 1 以及 j - 1 的最大连线数目中的最大值，和上一题完全相同。

2. dp 数组的含义

dp[i][j] 就是长度为 i - 1 的 nums1 和长度为 j - 1 的 nums2 的最大连线数目，这里就直接采用后移的方式来初始化了。

3. 递推公式

当 nums1[i] == nums[j] 的时候dp[i][j] = dp[i - 1][j - 1] + 1 此时的最多连线数目依赖于 dp[i - 1][j - 1] 的最多连线数目。

另外，当不相等的时候，dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]) 也就是前一段的最大值。

本题和上一题几乎是完全相同，转换一下 dp 数组的含义就可以很轻松的解答。

<3> 代码

class Solution {
    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];
    }
}

04. 最大子数组和（No. 53）

题目链接

代码随想录题解

<1> 题目

给你一个整数数组 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

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104

<2> 题解

1. 状态

又是一个关于子数组的题目，子数组也就代表着连续，这样就代表着状态中必须包含以什么为结尾。

所以本题中的状态就可以初步确定为以 nums[i] 为结尾的数组的最大的总和。

2. dp 数组的定义

dp[i] 就是以 nums[i] 为结尾的数组的最大总和。

3. 递推公式

对于一个 nums[i] 因为限制必须以它结尾，所以仅有两种情况，接着前面的继续取和从这个节点开始取，其中取一个最大值即可

dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);

然后因为最终的结果不一定以什么为结尾，所以每次要进行比较

count = Math.max(dp[i], count);

最后直接返回 count 即可

4. 初始化

只需要初始化 dp[0] 即可，回顾一下数组的定义：以 nums[i] 为结尾的数组的最大的总和。

那 dp[0] 就是以 nums[0] 结尾的总和，那就是 nums[0] 了。

然后记得将 count 也初始化为 dp[0] 就行了。

<3> 代码

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