583. 两个字符串的删除操作
1.题目描述
给定两个单词
word1
和word2
,返回使得word1
和word2
相同所需的最小步数。每步 可以删除任意一个字符串中的一个字符。
2.解题思路
- 动规五部曲:
- 确定dp数组以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
- 1.确定dp数组以及下标的含义
- dp[i][j]:以i-1为结尾的字符串word1,和以j-1位结尾的字符串word2,想要达到相等,所需要删除元素的最少次数。
- 2.确定递推公式
- 当word1[i - 1] 与 word2[j - 1]相同的时候,dp[i][j] = dp[i - 1][j - 1];
- 当word1[i - 1] 与 word2[j - 1]不相同的时候,有三种情况:
- 情况一:删word1[i - 1],最少操作次数为dp[i - 1][j] + 1
- 情况二:删word2[j - 1],最少操作次数为dp[i][j - 1] + 1
- 情况三:同时删word1[i - 1]和word2[j - 1],操作的最少次数为dp[i - 1][j - 1] + 2
- 那最后当然是取最小值,所以当word1[i - 1] 与 word2[j - 1]不相同的时候,递推公式:dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});
- 3.dp数组如何初始化
- 从递推公式中,可以看出来,dp[i][0] 和 dp[0][j]是一定要初始化的。
- dp[i][0]:word2为空字符串,以i-1为结尾的字符串word1要删除多少个元素,才能和word2相同呢,很明显dp[i][0] = i。
- 4.确定遍历顺序
从递推公式 dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});可以看出dp[i][j]都是根据左上方、正上方、正左方推出来的。
所以遍历的时候一定是从上到下,从左到右,这样保证dp[i][j]可以根据之前计算出来的数值进行计算。
- 5.举例推导dp数组
- 以word1:"sea",word2:"eat"为例,推导dp数组状态图如下:
3.代码实现
class Solution {
//583. 两个字符串的删除操作
public int minDistance(String word1, String word2) {
//dp[i][j]:以i-1为结尾的字符串word1,和以j-1位结尾的字符串word2,
// 想要达到相等,所需要删除元素的最少次数。
int[][] dp = new int[word1.length() + 1][word2.length() + 1];
//dp[i][0]:word2为空字符串,以i-1为结尾的字符串word1要删除多少个元素,才能和word2相同呢,
//很明显dp[i][0] = i。
for (int i = 0; i <= word1.length(); i++) {
dp[i][0] = i;
}
//dp[0][j]:word1为空字符串,以j-1为结尾的字符串word2要删除多少个元素,才能和word1相同呢,
//很明显dp[0][j] = j。
for (int j = 0; j <= word2.length(); j++) {
dp[0][j] = j;
}
for (int i = 1; i <= word1.length(); i++) {
for (int j = 1; j <= word2.length(); j++) {
if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1];
} else {
//当word1[i - 1] 与 word2[j - 1]不相同的时候,有三种情况:
//情况一:删word1[i - 1],最少操作次数为dp[i - 1][j] + 1
//情况二:删word2[j - 1],最少操作次数为dp[i][j - 1] + 1
//情况三:同时删word1[i - 1]和word2[j - 1],操作的最少次数为dp[i - 1][j - 1] + 2
dp[i][j] = Math.min(dp[i - 1][j] + 1, Math.min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 2));
}
}
}
return dp[word1.length()][word2.length()];
}
}
72. 编辑距离
1.题目描述
- 给你两个单词 word1 和 word2, 请返回将 word1 转换成 word2 所使用的最少操作数
- 你可以对一个单词进行如下三种操作:
- 插入一个字符
- 删除一个字符
- 替换一个字符
2.解题思路
- 1.确定dp数组以及下标的含义
- dp[i][j] 表示以下标i-1为结尾的字符串word1,和以下标j-1为结尾的字符串word2,最近编辑距离为dp[i][j]。
- 2.确定递推公式
- 在确定递推公式的时候,首先要考虑清楚编辑的几种操作,整理如下:
if (word1[i - 1] == word2[j - 1])
不操作
if (word1[i - 1] != word2[j - 1])
增
删
换
- 也就是如上4种情况。
if (word1[i - 1] == word2[j - 1])
那么说明不用任何编辑,dp[i][j]
就应该是dp[i - 1][j - 1]
,即dp[i][j] = dp[i - 1][j - 1];
if (word1[i - 1] != word2[j - 1])
,此时就需要编辑了,如何编辑呢?
- 操作一:word1删除一个元素,那么就是以下标i - 2为结尾的word1 与 j-1为结尾的word2的最近编辑距离 再加上一个操作。
- 即
dp[i][j] = dp[i - 1][j] + 1;
- 操作二:word2删除一个元素,那么就是以下标i - 1为结尾的word1 与 j-2为结尾的word2的最近编辑距离 再加上一个操作。
- 即
dp[i][j] = dp[i][j - 1] + 1;
- 这里有同学发现了,怎么都是删除元素,添加元素去哪了。
- word2添加一个元素,相当于word1删除一个元素,例如
word1 = "ad" ,word2 = "a"
,word1
删除元素'd'
和word2
添加一个元素'd'
,变成word1="a", word2="ad"
, 最终的操作数是一样! dp数组如下图所示意的:
a a d
+-----+-----+ +-----+-----+-----+
| 0 | 1 | | 0 | 1 | 2 |
+-----+-----+ ===> +-----+-----+-----+
a | 1 | 0 | a | 1 | 0 | 1 |
+-----+-----+ +-----+-----+-----+
d | 2 | 1 |
+-----+-----+
- 操作三:替换元素,
word1
替换word1[i - 1]
,使其与word2[j - 1]
相同,此时不用增加元素,那么以下标i-2
为结尾的word1
与j-2
为结尾的word2
的最近编辑距离 加上一个替换元素的操作。- 即
dp[i][j] = dp[i - 1][j - 1] + 1;
- 综上,当
if (word1[i - 1] != word2[j - 1])
时取最小的,即:dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
- 递归公式代码如下:
for (int i = 1; i <= word1.length(); i++) {
for (int j = 1; j <= word2.length(); j++) {
if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1];
} else {
//当word1[i - 1] 与 word2[j - 1]不相同的时候,有三种情况:
//情况一:删word1[i - 1],最少操作次数为dp[i - 1][j] + 1
//情况二:删word2[j - 1],最少操作次数为dp[i][j - 1] + 1
//情况三:替换元素,word1替换word1[i - 1],使其与word2[j - 1]相同,此时不用增加元素,
//那么以下标i-2为结尾的word1 与 j-2为结尾的word2的最近编辑距离 加上一个替换元素的操作。
//操作的最少次数为dp[i - 1][j - 1] + 2
dp[i][j] = Math.min(dp[i - 1][j] + 1, Math.min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));
}
}
}
- 3.dp数组如何初始化
- dp[i][0] :以下标i-1为结尾的字符串word1,和空字符串word2,最近编辑距离为dp[i][0]。
- 那么dp[i][0]就应该是i,对word1里的元素全部做删除操作,即:dp[i][0] = i;
- 同理dp[0][j] = j;
4.确定遍历顺序
- 从如下四个递推公式:
dp[i][j] = dp[i - 1][j - 1]
dp[i][j] = dp[i - 1][j - 1] + 1
dp[i][j] = dp[i][j - 1] + 1
dp[i][j] = dp[i - 1][j] + 1
- 可以看出dp[i][j]是依赖左方,上方和左上方元素的,如图:
- 所以在dp矩阵中一定是从左到右从上到下去遍历。
- 5.举例推导dp数组
以示例1为例,输入:
word1 = "horse", word2 = "ros"
为例,dp矩阵状态图如下:
3.代码实现
class Solution {
//72. 编辑距离
public int minDistance(String word1, String word2) {
//dp[i][j]:以下标i-1为结尾的字符串word1,和以下标j-1为结尾的字符串word2,最近编辑距离为dp[i][j]。
int[][] dp = new int[word1.length() + 1][word2.length() + 1];
//dp[i][0]:word2为空字符串,以i-1为结尾的字符串word1要删除多少个元素,才能和word2相同呢,
//很明显dp[i][0] = i。
for (int i = 0; i <= word1.length(); i++) {
dp[i][0] = i;
}
//dp[0][j]:word1为空字符串,以j-1为结尾的字符串word2要删除多少个元素,才能和word1相同呢,
//很明显dp[0][j] = j。
for (int j = 0; j <= word2.length(); j++) {
dp[0][j] = j;
}
for (int i = 1; i <= word1.length(); i++) {
for (int j = 1; j <= word2.length(); j++) {
if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1];
} else {
//当word1[i - 1] 与 word2[j - 1]不相同的时候,有三种情况:
//情况一:删word1[i - 1],最少操作次数为dp[i - 1][j] + 1
//情况二:删word2[j - 1],最少操作次数为dp[i][j - 1] + 1
//情况三:替换元素,word1替换word1[i - 1],使其与word2[j - 1]相同,此时不用增加元素,
//那么以下标i-2为结尾的word1 与 j-2为结尾的word2的最近编辑距离 加上一个替换元素的操作。
//操作的最少次数为dp[i - 1][j - 1] + 2
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[word1.length()][word2.length()];
}
}
647. 回文子串
1.题目描述
- 给你一个字符串 s ,请你统计并返回这个字符串中 回文子串 的数目。
- 回文字符串 是正着读和倒过来读一样的字符串。
- 子字符串 是字符串中的由连续字符组成的一个序列。
- 具有不同开始位置或结束位置的子串,即使是由相同的字符组成,也会被视作不同的子串。
2.解题思路
- 1.确定dp数组以及下标的含义
- 布尔类型的dp[i][j]:表示区间范围[i,j] (注意是左闭右闭)的子串是否是回文子串,如果是dp[i][j]为true,否则为false。
- 2.确定递推公式
- 整体上是两种,就是s[i]与s[j]相等,s[i]与s[j]不相等这两种。
- 当s[i]与s[j]不相等,那没啥好说的了,dp[i][j]一定是false。
- 当s[i]与s[j]相等时,这就复杂一些了,有如下三种情况
- 情况一:下标i 与 j相同,同一个字符例如a,当然是回文子串
- 情况二:下标i 与 j相差为1,例如aa,也是回文子串
- 情况三:下标:i 与 j相差大于1的时候,例如cabac,此时s[i]与s[j]已经相同了,我们看i到j区间是不是回文子串就看aba是不是回文就可以了,那么aba的区间就是 i+1 与 j-1区间,这个区间是不是回文就看dp[i + 1][j - 1]是否为true。
for (int i = s.length() - 1; i >= 0; i--) {
for (int j = i; j < s.length(); j++) {
//当两端字母一样时,才可以两端收缩进一步判断
if (s.charAt(i) == s.charAt(j)) {
//情况一:下标i 与 j相同,同一个字符例如a,当然是回文子串
//情况二:下标i 与 j相差为1,例如aa,也是回文子串
if (j - i < 3) {
dp[i][j] = true;
} else {
//情况三:下标i与j相差大于1的时候,例如cabac,
//此时s[i]与s[j]已经相同了,我们看i到j区间是不是回文子串就看aba是不是回文就可以了,
//那么aba的区间就是 i+1 与 j-1区间,这个区间是不是回文就看dp[i + 1][j - 1]是否为true。
dp[i][j] = dp[i + 1][j - 1];
}
} else {//两端字符不一样,不是回文串
dp[i][j] = false;
}
}
}
- 3.dp数组如何初始化
- dp[i][j]可以初始化为true么? 当然不行,怎能刚开始就全都匹配上了。
- 所以dp[i][j]初始化为false。
- 4.确定遍历顺序
- 遍历顺序可有有点讲究了。
- 首先从递推公式中可以看出,情况三是根据dp[i + 1][j - 1]是否为true,在对dp[i][j]进行赋值true的。
- dp[i + 1][j - 1] 在 dp[i][j]的左下角,如图:
- 如果这矩阵是从上到下,从左到右遍历,那么会用到没有计算过的dp[i + 1][j - 1],也就是根据不确定是不是回文的区间[i+1,j-1],来判断了[i,j]是不是回文,那结果一定是不对的。
- 所以一定要从下到上,从左到右遍历,这样保证dp[i + 1][j - 1]都是经过计算的。
- 有的代码实现是优先遍历列,然后遍历行,其实也是一个道理,都是为了保证dp[i + 1][j - 1]都是经过计算的。
- 5.举例推导dp数组
- 举例,输入:"aaa",dp[i][j]状态如下:
- 图中有6个true,所以就是有6个回文子串。
- 注意因为dp[i][j]的定义,所以j一定是大于等于i的,那么在填充dp[i][j]的时候一定是只填充右上半部分。
3.代码实现
class Solution {
//647. 回文子串
public int countSubstrings(String s) {
int res = 0;
//dp[i][j]:s字符串下标i到下标j的字串是否是一个回文串,即s[i, j]
boolean[][] dp = new boolean[s.length()][s.length()];
for (int i = s.length() - 1; i >= 0; i--) {
for (int j = i; j < s.length(); j++) {
//当两端字母一样时,才可以两端收缩进一步判断
if (s.charAt(i) == s.charAt(j)) {
//情况一:下标i 与 j相同,同一个字符例如a,当然是回文子串
//情况二:下标i 与 j相差为1,例如aa,也是回文子串
if (j - i < 3) {
dp[i][j] = true;
} else {
//情况三:下标i与j相差大于1的时候,例如cabac,
//此时s[i]与s[j]已经相同了,我们看i到j区间是不是回文子串就看aba是不是回文就可以了,
//那么aba的区间就是 i+1 与 j-1区间,这个区间是不是回文就看dp[i + 1][j - 1]是否为true。
dp[i][j] = dp[i + 1][j - 1];
}
} else {//两端字符不一样,不是回文串
dp[i][j] = false;
}
}
}
//遍历每一个字串,统计回文串个数
for (int i = 0; i < s.length(); i++) {
for (int j = 0; j < s.length(); j++) {
if (dp[i][j]) res++;
}
}
return res;
}
}
516.最长回文子序列
1.题目描述
- 给你一个字符串 s ,找出其中最长的回文子序列,并返回该序列的长度。
- 子序列定义为:不改变剩余字符顺序的情况下,删除某些字符或者不删除任何字符形成的一个序列
2.解题思路
- 1.确定dp数组以及下标的含义
- dp[i][j]:字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
- 2.确定递推公式
- 在判断回文子串的题目中,关键逻辑就是看s[i]与s[j]是否相同。
- 如果s[i]与s[j]相同,那么dp[i][j] = dp[i + 1][j - 1] + 2;
- 如图:
- 如果s[i]与s[j]不相同,说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子串的长度,那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。
- 加入s[j]的回文子序列长度为dp[i + 1][j]。
- 加入s[i]的回文子序列长度为dp[i][j - 1]。
- 那么dp[i][j]一定是取最大的,即:dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
代码如下:
for (int i = n - 1; i >= 0; i--) {
dp[i][i] = 1;
for (int j = i + 1; j < n; j++) {
if (str.charAt(i) == str.charAt(j)) {
//如果s[i]与s[j]相同,那么dp[i][j] = dp[i + 1][j - 1] + 2;
dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
//如果s[i]与s[j]不相同,说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子串的长度,那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。
//情况1:加入s[j]的回文子序列长度为dp[i + 1][j]。
//情况2:加入s[i]的回文子序列长度为dp[i][j - 1]。
//取值:那么dp[i][j]一定是取最大的,即:dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
}
}
}
- 3.dp数组如何初始化
- 首先要考虑当i 和j 相同的情况,从递推公式:dp[i][j] = dp[i + 1][j - 1] + 2; 可以看出 递推公式是计算不到 i 和j相同时候的情况。
- 所以需要手动初始化一下,当i与j相同,那么dp[i][j]一定是等于1的,即:一个字符的回文子序列长度就是1。
- 其他情况dp[i][j]初始为0就行,这样递推公式:dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]); 中dp[i][j]才不会被初始值覆盖
- 4.确定遍历顺序
- 从递推公式dp[i][j] = dp[i + 1][j - 1] + 2 和 dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]) 可以看出,dp[i][j]是依赖于dp[i + 1][j - 1] 和 dp[i + 1][j],
- 也就是从矩阵的角度来说,dp[i][j] 下一行的数据。 所以遍历i的时候一定要从下到上遍历,这样才能保证,下一行的数据是经过计算的。
- 递推公式:dp[i][j] = dp[i + 1][j - 1] + 2,dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]) 分别对应着下图中的红色箭头方向,如图:
- 如果这矩阵是从上到下,从左到右遍历,那么会用到没有计算过的dp[i + 1][j - 1],也就是根据不确定是不是回文的区间[i+1,j-1],来判断了[i,j]是不是回文,那结果一定是不对的。
- 所以一定要从下到上,从左到右遍历,这样保证dp[i + 1][j - 1]都是经过计算的。
- 有的代码实现是优先遍历列,然后遍历行,其实也是一个道理,都是为了保证dp[i + 1][j - 1]都是经过计算的。
- 5.举例推导dp数组
- 输入s:"cbbd" 为例,dp数组状态如图:
3.代码实现
class Solution {
//516.最长回文子序列
public static int longestPalindromeSubseq(String str) {
int n = str.length();
//dp[i][j]:字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
int[][] dp = new int[n][n];
for (int i = n - 1; i >= 0; i--) {
dp[i][i] = 1;
for (int j = i + 1; j < n; j++) {
if (str.charAt(i) == str.charAt(j)) {
//如果s[i]与s[j]相同,那么dp[i][j] = dp[i + 1][j - 1] + 2;
dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
//如果s[i]与s[j]不相同,说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子串的长度,那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。
//情况1:加入s[j]的回文子序列长度为dp[i + 1][j]。
//情况2:加入s[i]的回文子序列长度为dp[i][j - 1]。
//取值:那么dp[i][j]一定是取最大的,即:dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
}
}
}
return dp[0][n - 1];
}
}