【力扣】【4】不同的子序列

题目

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

示例 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

提示：

1 <= s.length, t.length <= 1000
s 和 t 由英文字母组成

My题解

二维：

class Solution {
    public int numDistinct(String s, String t) {
        int[][] dp= new int[1010][1010];
            for (int j=0;j<=s.length();j++)
                dp[0][j]=1;

        int i=0,j=0;
        for ( i=1;i<=t.length();i++) {
            for (j = 1; j <= s.length(); j++) {
                if (t.charAt(i-1) == s.charAt(j-1)) {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i][j - 1];
                } else {
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
        return  dp[t.length()][s.length()];

    }
}

优化题解

一维：

class Solution {
    public int numDistinct(String s, String t) {
        int lenS = s.length(),lenT=t.length();
        if(lenS<lenT)
            return 0;
        
        int[] dp=new int[lenT+1];
        for (int i=1;i<=lenS;i++){
            dp[0]=1;
            for (int j=lenT;j>=1;j--){
                if(s.charAt(i-1)==t.charAt(j-1)){
                    dp[j]+=dp[j-1];
                }
            }
        }
        return dp[lenT];
    }
}

进阶题解

  class Solution {
    public int numDistinct(String s, String t) {
        //dfs--深度优先搜索【不能过，但可以有助于理解】
        char[] sChars = s.toCharArray();
        char[] tChars = s.toCharArray();
        return dfs(sChars,tChars,0,0,0);
    }
    int dfs(char[] sChars,char[] tChars,int sIdx,int tIdx,int count){
        if(sIdx<sChars.length&&tIdx<tChars.length){
            if(sChars[sIdx]==tChars[tIdx]){// 当前对应位置字符匹配
                if(tIdx==tChars.length-1){
                    count++;
                }
                 // 如果当前字符匹配，则s指针与t指针同步后移，继续进行递归匹配
                count=dfs(sChars,tChars,sIdx+1,tIdx+1,count);
            }
            // 无论当前字符是否匹配，都进行一次只移动s指针的递归
            count = dfs(sChars, tChars, sIdx+1, tIdx, count);

        }
        return count;
    }
}

总结

关于字符串匹配，通常有两种（你也可以理解为一种）通用的状态定义：

f[i][j] 表示「第一个字符 s 中 [0,i][0,i][0,i] 个字符」与「第二个字符 t 中 [0,j][0,j][0,j] 个字符」的匹配结果

f[i][j] 表示「第一个字符 s 中 [0,i][0,i][0,i] 个字符」与「第二个字符 t 中 [0,j][0,j][0,j] 个字符」且 「最后一个字符为 t[j]」的匹配结果

拓展

动态规划
DFS

相关链接

https://leetcode.cn/problems/distinct-subsequences/description/