代码随想录算法训练营第三十八天、三十九天|动态规划part11、12

LeetCode 1143 最长公共子序列

题目链接：1143. 最长公共子序列 - 力扣（LeetCode）

给定两个字符串 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.确定dp数组以及下标的含义：

dpij表示text1前i个元素和text2前j个元素的最长公共子序列的长度。

2.递推公式：

如果text1i-1==text2j-1，dpij=dpi-1j-1+1；

如果text1i-1!=text2j-1，有两种情况：

text1的前i个元素和text2的前j个元素的最长公共子序列的最后一个元素不等于text1i-1，说明这个最长公共子序列是text1的前i-1个元素和text2的前j个元素的最长公共子序列，所以dpij=dpi-1j；

text1的前i个元素和text2的前j个元素的最长公共子序列的最后一个元素不等于text2j-1，说明这个最长公共子序列是text1的前i个元素和text2的前j-1个元素的最长公共子序列，所以dpij=dpij-1。

所以dpij=max(dpi-1j,dpij-1)。

3.初始化：

初始化dp数组第一行第一列均为0即可，表示任何一个字符串为空时，最长公共子序列的长度肯定为0。

4.确定遍历顺序：

行优先从前向后遍历。

5.举例推导dp数组：

代码如下：

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

LeetCode 1035 不相交的线

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

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

现在，可以绘制一些连接两个数字 nums1i 和 nums2j 的直线，这些直线需要同时满足：

nums1i == nums2j

且绘制的直线不与任何其他连线（非水平线）相交。

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

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

示例 1：

输入：nums1 = 1,4,2, nums2 = 1,2,4

输出：2

解释：可以画出两条不交叉的线，如上图所示。

但无法画出第三条不相交的直线，因为从 nums11=4 到 nums22=4 的直线将与从 nums12=2 到 nums21=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

这个题本质就是求两个数组的最大公共子序列，和上一题一样。

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

LeetCode 53 最大子数组和

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

给你一个整数数组 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.确定dp数组以及下标含义：

dpi表示nums0-i的连续子数组的最大和。

2.递推公式：

dpi只有两个方向可以推出来：

dpi-1+numsi，即numsi加入当前连续子数组和；

numsi，即从头开始计算连续子数组和。

所以dpi = max(dpi - 1 + numsi, numsi)。

3.初始化：

初始化dp0=nums0。

4.确定遍历顺序：从前向后遍历。

5.举例推导dp数组：

代码如下：

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

LeetCode 392 判断子序列

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

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

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

示例 1：

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

输出：true

示例 2：

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

输出：false

这个题本质和求两个字符串的最长公共子序列是一样的，只不过最后判断最长公共子序列的长度等于s的长度就返回true，否则返回false。

代码如下：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m=s.length();
        int n=t.length();
        int[][] dp=new int[m+1][n+1];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(s.charAt(i-1)==t.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]);
            }
        }
        if(dp[m][n]==m)return true;
        else return false;
    }
}

LeetCode 115 不同的子序列

题目链接：115. 不同的子序列 - 力扣（LeetCode）

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数。

测试用例保证结果在 32 位有符号整数范围内。

示例 1：

输入：s = "rabbbit", t = "rabbit"

输出：3

解释：

如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。

rabbbit

rabbbit

rabbbit

示例 2：

输入：s = "babgbag", t = "bag"

输出：5

解释：

如下所示, 有 5 种可以从 s 中得到 "bag" 的方案。

babgbag

babgbag

babgbag

babgbag

babgbag

这个题可以等价于判断有多少种方式删减s可以得到t。

1.确定dp数组以及下标的含义：

dpij表示s的前i个元素通过删减可以得到t的前j个元素的方法。

2.递推公式：

如果si-1==tj-1，那么dpij有两种可能：

一种是保留下si-1，也就是s的前i-1个元素通过删减可以得到t的前j-1个元素的方法；

一种是不保留si-1，也就是s的前i-1个元素通过删减可以得到t的前j个元素的方法。

所以dpij=dpi-1j-1+dpi-1j。

如果si-1！=tj-1，那么dpij只有一种可能，也就是s的前i-1个元素通过删减可以得到t的前j个元素的方法，即dpij=dpi-1j。

3.初始化：

初始化dpi0=1（0<=i<=m），表示当t为空字符串时，s只有一种方法可以得到t，那就是全部删减掉；初始化dp0j=0（1<=j<=n），表示当s为空字符串时，除非t也为空字符串，否则s永远无法得到t。

4.确定遍历顺序：行优先从前向后遍历。

5.举例推导dp数组：

代码如下：

class Solution {
    public int numDistinct(String s, String t) {
        int m=s.length();
        int n=t.length();
        int[][] dp=new int[m+1][n+1];
        for(int i=0;i<=m;i++)dp[i][0]=1;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;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[m][n];
    }
}

LeetCode 583 两个字符串的删除操作

题目链接：583. 两个字符串的删除操作 - 力扣（LeetCode）

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步 可以删除任意一个字符串中的一个字符。

示例 1：

输入: word1 = "sea", word2 = "eat"

输出: 2

解释: 第一步将 "sea" 变为 "ea" ，第二步将 "eat "变为 "ea"

示例 2:

输入：word1 = "leetcode", word2 = "etco"

输出：4

1.确定dp数组以及下标的含义：

dpij表示word1的前i个元素和word2的前j个元素想要相同需要的最小步数。

2.递推公式：

当word1i-1==word2j-1时，dpij只有一种可能，也就是word1的前i-1个元素和word2的前j-1个元素想要相同需要的最小步数，即dpij=dpi-1j-1。

当word1i-1！=word2j-1时，dpij有三种可能：

一种是word1的前i-1个元素和word2的前j个元素想要相同需要的最小步数+1，也就是把word1i-1删掉；word1的前i个元素和word2的前j-1个元素想要相同需要的最小步数+1，也就是把word2j-1删掉；word1的前i-1个元素和word2的前j-1个元素想要相同需要的最小步数+2，也就是把两个都删掉。

所以dpij = min(dpi - 1j - 1 + 2, dpi - 1j + 1, dpij - 1 + 1)，又因为dpij - 1 + 1 = dpi - 1j - 1 + 2，所以可以简化为：dpij = min(dpi - 1j + 1, dpij - 1 + 1)。

3.初始化：

初始化dpi0=i（1<=i<=m），表示当word2为空字符串时，word1需要删除i个元素才能和word2相同；同样的,dp0j=j（1<=j<=n）。

4.确定遍历顺序：行优先从前向后遍历。

5.举例推导dp数组：

代码如下：

class Solution {
    public int minDistance(String word1, String word2) {
        int m=word1.length();
        int n=word2.length();
        int[][] dp=new int[m+1][n+1];
        for(int i=1;i<=m;i++)dp[i][0]=i;
        for(int j=1;j<=n;j++)dp[0][j]=j;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(word1.charAt(i-1)==word2.charAt(j-1))dp[i][j]=dp[i-1][j-1];
                else dp[i][j]=Math.min(dp[i-1][j]+1,dp[i][j-1]+1);
            }
        }
        return dp[m][n];
    }
}

LeetCode 72 编辑距离

题目链接：72. 编辑距离 - 力扣（LeetCode）

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

• 插入一个字符
• 删除一个字符
• 替换一个字符

示例 1：

输入：word1 = "horse", word2 = "ros"

输出：3

解释：

horse -> rorse (将 'h' 替换为 'r')

rorse -> rose (删除 'r')

rose -> ros (删除 'e')

示例 2：

输入：word1 = "intention", word2 = "execution"

输出：5

解释：

intention -> inention (删除 't')

inention -> enention (将 'i' 替换为 'e')

enention -> exention (将 'n' 替换为 'x')

exention -> exection (将 'n' 替换为 'c')

exection -> execution (插入 'u')

这个题和上一题不同之处在于不止可以删除元素，还可以替换、插入，但实际上插入元素和删除元素本质是一样的，所以我们只需再独立考虑一个替换元素的情况。

当word1i-1==word2j-1时，dpij依旧只可能等于dpi-1j-1；

当word1i-1!=word2j-1时，dpij有三种可能：

一种是删除word1i-1（或者在word2j之前插入word1i-1），也就是dpij=dpi-1j；

一种是删除word2j-1（或者在word1i之前插入word2j-1），也就是dpij=dpij-1；

一种是替换word1i-1为word2j-1，也就是dpij=dpi-1j-1+1。

所以dpij=min(dpi-1j+1,dpij-1+1,dpi-1j-1+1)。

class Solution {
    public int minDistance(String word1, String word2) {
        int m=word1.length();
        int n=word2.length();
        int[][] dp=new int[m+1][n+1];
        for(int i=0;i<=m;i++)dp[i][0]=i;
        for(int j=1;j<=n;j++)dp[0][j]=j;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(word1.charAt(i-1)==word2.charAt(j-1))dp[i][j]=dp[i-1][j-1];
                else dp[i][j]=Math.min(dp[i-1][j]+1,Math.min(dp[i][j-1]+1,dp[i-1][j-1]+1));
            }
        }
        return dp[m][n];
    }
}