算法训练营Day46

#Java #动态规划

Feeling and experiences：

判断子序列：力扣题目链接

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

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

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

示例 1：

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

这里，可以用到双指针的解法：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m = s.length();
        int n = t.length();
        int i = 0,j = 0;
        while(i < m&&j<n){
            if(s.charAt(i)==t.charAt(j)){
                i++;
            }
            j++;
        }
        if(i == m){
            return true;
        }
        return false;
    }
}

这种方法较为简单，当然也可以用动态规划的写法：

class Solution {
    public boolean isSubsequence(String s, String t) {
        // 创建dp数组，表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。
        int[][] dp = new int[s.length() + 1][t.length() + 1];

        // 初始化：默认一行一列都为0
        for (int i = 0; i <= s.length(); i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= t.length(); j++) {
            dp[0][j] = 0;
        }

        for (int i = 1; i <= s.length(); i++) {
            for (int j = 1; j <= t.length(); j++) {
                // 判断字符是否相等
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    // 如果相等，累积前面的匹配次数
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    // 否则，取上方的值
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }

        // 判断是否整个s都是t的子序列
        return dp[s.length()][t.length()] == s.length();
    }
}

定义dp数组：

dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

从这张图解中，就可以很好理解了（来自代码随想录）：

不同的子序列：力扣题目链接

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 10e9 + 7 取模。

示例 1：

输入：s = "rabbbit", t = "rabbit"
输出：3
解释：
如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
rabbbit
rabbbit
rabbbit

 动态规划：

public class Solution {
    public int numDistinct(String s, String t) {
        // 创建二维数组dp，dp[i][j]表示s的前i个字符组成的子串中t的前j个字符组成的子串出现的次数
        int[][] dp = new int[s.length() + 1][t.length() + 1];

        // 初始化：对于任意的i，s的前i个字符组成的子串中t的前0个字符组成的子串都只有一种情况，即空串
        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的第i个字符等于t的第j个字符
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    // dp[i][j]可以由两部分组成：
                    // 1. 使用s的前i-1个字符组成的子串中t的前j-1个字符组成的子串出现的次数，即dp[i-1][j-1]
                    // 2. 使用s的前i-1个字符组成的子串中t的前j个字符组成的子串出现的次数，即dp[i-1][j]
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    // 如果s的第i个字符不等于t的第j个字符，dp[i][j]只能由s的前i-1个字符组成的子串中t的前j个字符组成的子串出现的次数得到，即dp[i-1][j]
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // 返回s的前s.length()个字符组成的子串中t的前t.length()个字符组成的子串出现的次数
        return dp[s.length()][t.length()];
    }
}

• 定义状态： 我们定义二维数组 dp[i][j] 表示字符串 s 的前 i 个字符组成的子串中，字符串 t 的前 j 个字符组成的子串出现的次数。

• 初始化： 对于任意 i，s 的前 i 个字符组成的子串中，t 的前 0 个字符组成的子串都只有一种情况，即空串。因此，我们将 dp[i][0] 初始化为 1。

• i 表示考虑的是字符串 s 的前 i 个字符，而不包括第 i 个字符。这是因为我们在状态转移的过程中，通常是通过考虑第 i 个字符的情况来更新状态，而不是将第 i 个字符直接加入。

  考虑状态转移方程的逻辑，例如在此问题中：

• 如果 s 的第 i 个字符等于 t 的第 j 个字符，那么 dp[i][j] 可以由两部分组成：
  1. 使用 s 的前 i-1 个字符组成的子串中 t 的前 j-1 个字符组成的子串出现的次数，即 dp[i-1][j-1]。
  2. 使用 s 的前 i-1 个字符组成的子串中 t 的前 j 个字符组成的子串出现的次数，即 dp[i-1][j]。

如果 s 的第 i 个字符不等于 t 的第 j 个字符，那么 dp[i][j] 只能由 s 的前 i-1 个字符组成的子串中 t 的前 j 个字符组成的子串出现的次数得到，即 dp[i-1][j]。

代码随想录中的图解：

都来此事，眉间心上，无计相回避。

Fighting！