#115 Distinct Subsequences

Description

Given two strings s and t, return the number of distinct subsequences of s which equals t.

A string’s subsequence is a new string formed from the original string by deleting some (can be none) of the characters without disturbing the remaining characters’ relative positions. (i.e., “ACE” is a subsequence of “ABCDE” while “AEC” is not).

The test cases are generated so that the answer fits on a 32-bit signed integer.

Examples

Example 1:

Input: s = “rabbbit”, t = “rabbit”
Output: 3
Explanation:
As shown below, there are 3 ways you can generate “rabbit” from S.
rabbbit
rabbbit
rabbbit

Example 2:

Input: s = “babgbag”, t = “bag”
Output: 5
Explanation:
As shown below, there are 5 ways you can generate “bag” from S.
babgbag
babgbag
babgbag
babgbag
babgbag

Constraints:

1 <= s.length, t.length <= 1000
s and t consist of English letters.

思路

又是dp，但是这次是自己推出状态转移公式的！

想不出来的时候可以先用简单的字符试一试，比如题目给出的例子是rabbit和rabbbit，其实里面的难点就在于bb和bbb，显而易见有两个string的情况是要构建2D dp的，那么就通过bb和bbb的表格来寻找可能的状态转移方程

单元格内表示 s.substring(0, j) ~ t.substring(0, i) 有几种组成方式

-	b	b	b
b	1	2	3
b	-	1	3

好像看不出什么
再加一点试试

-	b	b	b	b
b	1	2	3	4
b	-	1	3	6

现在有点感觉了，但我一开始只能想到6=1+2+3，再看一看发现，3=1+2，那不就是左侧单元格+左上侧单元格吗？

再分析一下这个状态转移公式的物理意义：如果 $t(i)=s(j)$，那么他的可能路径由两部分组成

• $dp[i][j-1]$，也就是同样对于这 $i$ 个 $t$ 中的单词，如果仅仅使用 $j-1$ 个$s$ 中的单词进行组合，可能路径的数量
• $dp[i-1][j-1]$，因为$t(i)=s(j)$，所以对于 $t$ 中的前 $i-1$ 个单词有 $dp[i-1][j-1]$ 条可能路径，这些路径可以直接加进来作为可用路径

如果 $t(i)\ne s(j)$，就只有 $dp[i][j-1]$ 种路径啦

当然初始化要注意是 $dp[i][0]=0$，$dp[0][j]=1$，这个的原因可以通过表格发现

代码

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