代码随想录刷题day55｜判断子序列&不同的子序列

最新推荐文章于 2024-07-15 16:49:44 发布

Yang_Yang_66666

最新推荐文章于 2024-07-15 16:49:44 发布

阅读量1k

点赞数 8

分类专栏：算法文章标签：算法

本文链接：https://blog.csdn.net/Yang_Yang_66666/article/details/137796157

版权

算法专栏收录该内容

54 篇文章 2 订阅

订阅专栏

day55学习内容

day55主要内容

判断子序列
不同的子序列

声明
本文思路和文字，引用自《代码随想录》

一、判断子序列

392.原题链接

1.1、动态规划五部曲

1.1.1、确定dp数组（dp table）以及下标的含义

dp[i][j]表示字符串s的前i个字符和字符串t的前j个字符时，s的前i个字符能在t的前j个字符中形成的最长子序列的长度。

1.1.2、确定递推公式

初始化：
- 创建一个二维数组（或表），其大小基于两个字符串的长度。这个表用于保存中间结果，具体地，表中的每个位置(i, j)存储的是考虑s的前i个字符和t的前j个字符时，s能在t中表示的最大子序列的长度。
填表策略：

遍历这两个字符串的每个字符，对于字符串s的每个字符，检查它是否在字符串t中的当前位置字符相等。
如果相等，这意味着这个字符可以成为考虑到目前为止的子序列的一部分，此时子序列的长度可以增加。
如果不相等，就查看不包括当前字符的最长子序列长度（即之前的最优解）。

1.1.3、 dp数组如何初始化

数组维度：
- dp是一个(length1+1) x (length2+1)的二维数组，其中length1和length2分别是字符串s和t的长度。
- 为什么是length+1？这是为了包含空字符串的情况，使得索引操作可以直接使用字符串的长度，方便理解和编码。
基础值设置：
- dp[0][0]表示两个空字符串的最长子序列长度，自然是0。
- dp[i][0]表示任意长度的字符串s与空字符串t的最长子序列长度，也是0，因为空字符串不包含任何字符，所以最长子序列只能是空，长度为0。
- dp[0][j]同理，表示空字符串s与任意长度的字符串t的最长子序列长度也是0。

在Java中，所有数组元素默认初始化为0。因此，可以直接声明数组，无需显式设置上述基础值（因为它们都是0）。但为了清晰，有时候在逻辑上理解我们确实是"初始化"这些值为0。

int[][] dp = new int[length1+1][length2+1];
// 默认情况下，Java中的int数组元素初始化为0
// 所以 dp[0][0], dp[i][0], dp[0][j] 都已经被初始化为0

1.1.4、确定遍历顺序

从小到大遍历

1.1.5、输出结果

最后，查看整个表的最后一个元素（它代表了两个字符串完整考虑时的最长子序列长度）。如果这个长度等于s的长度，那么可以确认s是t的子序列。
否则，s不是t的子序列。

1.2、代码

class Solution {
    public boolean isSubsequence(String s, String t) {
        // 获取输入字符串s和t的长度
        int length1 = s.length(); 
        int length2 = t.length();
        
        // 创建一个动态规划表格，大小为 (length1+1)x(length2+1)
        // dp[i][j]表示字符串s的前i个字符是否可以在字符串t的前j个字符中以子序列的形式出现
        int[][] dp = new int[length1+1][length2+1];
        
        // 通过双层循环填充动态规划表
        for(int i = 1; i <= length1; i++){
            for(int j = 1; j <= length2; j++){
                // 如果s的第i个字符与t的第j个字符相等
                if(s.charAt(i-1) == t.charAt(j-1)){
                    // 表示这两个字符可以形成子序列的一部分
                    // dp[i][j]在dp[i-1][j-1]的基础上加1
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    // 如果不相等，那么忽略t的这个字符，看s的前i个字符是否可以在t的前j-1个字符中形成子序列
                    dp[i][j] = dp[i][j-1];
                }
            }
        }
        
        // 最终判断s的长度是否等于dp表中s和t全部考虑后的值
        // 如果等于，表示s可以完整地作为子序列在t中出现
        if(dp[length1][length2] == length1){
            return true;
        }else{
            return false;
        }
    }
}

二、不同的子序列–写不出来，抄的

115.原题链接

2.1、动态规划五部曲

2.1.1、确定dp数组（dp table）以及下标的含义

其中dp[i][j]代表考虑s的前i个字符时，有多少种方法可以形成t的前j个字符作为子序列。

2.1.2、确定递推公式

外层循环遍历字符串s的每一个字符，内层循环遍历字符串t的每一个字符。
如果当前s和t的字符相同（s.charAt(i-1) == t.charAt(j-1)），这时有两种选择：
- 使用这个字符：如果我们决定使用s中的这个字符作为子序列的一部分，那么我们需要看在不包括这个字符之前，有多少种方式可以匹配t中除去当前字符的剩余部分（dp[i-1][j-1]）。
- 不使用这个字符：同时，我们还可以选择不使用s中的这个字符，看有多少种方式可以只使用s中前面的部分来匹配t中当前长度（dp[i-1][j]）。
将这两种选择的结果相加得到dp[i][j]。
如果当前s和t的字符不同，那么dp[i][j]的值就等于dp[i-1][j]，意味着我们只能选择忽略s中的这个字符，看前面的部分如何匹配。

2.1.3、 dp数组如何初始化

数组dp的所有行的第一列都被初始化为1 (dp[i][0] = 1)。这是因为一个非空字符串形成一个空字符串的子序列只有一种方法，那就是删除所有字符。所以，无论s的长度如何，总是有一种方法（删除所有字符）来匹配空字符串t。

2.1.4、确定遍历顺序

外层循环 - 遍历s（源字符串）

在外层循环中，我们遍历字符串s，即考虑的是从s的开始到第i个字符的所有可能子序列。i从1到s.length()，这表示我们逐步增加考虑的s的长度：

for (int i = 1; i < s.length() + 1; i++) {
    ...
}

为什么从1开始：i=1代表至少考虑s的第一个字符。这里的索引是针对动态规划数组dp设置的，其中dp[i][...]表示的是包括s的前i个字符（由于数组从0开始，所以i-1在字符串中是第i个字符）。

内层循环 - 遍历t（目标子序列字符串）

内层循环遍历字符串t，即考虑的是从t的开始到第j个字符的所有可能情况。j从1到t.length()，这代表逐步增加考虑的t的长度：

for (int j = 1; j < t.length() + 1; j++) {
    ...
}

为什么从1开始：同样，j=1表示至少包括t的第一个字符。dp[...][j]在动态规划数组中代表包括t的前j个字符的所有考虑。
3. 总结
这样的遍历策略（先逐个增加s的长度，对于每个s的长度再逐个增加t的长度）是解决这类字符串动态规划问题的常用方法。它确保了每个子问题都被按依赖顺序解决，每次迭代都在构建之前结果的基础上进行，从而有效地填充了整个动态规划表。这种方法不仅逻辑清晰，而且在实现上也便于编码和调试。

2.1.5、输出结果

dp[s.length()][t.length()]存储的是使用整个s字符串来形成整个t字符串作为子序列的方法数。

2.2、代码

class Solution {
    public int numDistinct(String s, String t) {
        // 创建一个二维数组dp，大小为(s.length() + 1) x (t.length() + 1)
        int[][] dp = new int[s.length() + 1][t.length() + 1];

        // 初始化dp数组的第一列，所有dp[i][0]设置为1
        // 因为一个非空字符串形成一个空字符串的子序列只有一种方法，即删除所有字符
        for (int i = 0; i < s.length() + 1; i++) {
            dp[i][0] = 1;
        }
        
        // 使用双层循环遍历字符串s和t
        for (int i = 1; i < s.length() + 1; i++) {
            for (int j = 1; j < t.length() + 1; j++) {
                // 如果s和t在当前位置字符相同
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    // dp[i][j] 可以由两部分组成：
                    // 1. 使用当前匹配的字符，即加上dp[i-1][j-1]
                    // 2. 不使用s中的当前字符，即dp[i-1][j]
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    // 如果当前字符不匹配，那么只能考虑不使用s中的当前字符的情况
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        
        // dp[s.length()][t.length()]包含了使用整个s字符串匹配整个t字符串的方法数
        return dp[s.length()][t.length()];
    }
}