Given a string S and a string T, count the number of distinct subsequences of S which equals T.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE"

Example 1:

Input: S = "rabbbit", T = "rabbit"
Output: 3
Explanation:

As shown below, there are 3 ways you can generate "rabbit" from S.
(The caret symbol ^ means the chosen letters)

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.
(The caret symbol ^ means the chosen letters)

babgbag
^^ ^
babgbag
^^    ^
babgbag
^    ^^
babgbag
  ^  ^^
babgbag
    ^^^

給定一個字串 S 和一個字串 T，計算在 S 的子序列中 T 出現的個數。

一個字串的一個子序列是指，通過刪除一些（也可以不刪除）字元且不干擾剩餘字元相對位置所組成的新字串。（例如，"ACE" 是 "ABCDE" 的一個子序列，而 "AEC" 不是）

示例 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 class Solution {
 2     func numDistinct(_ s: String, _ t: String) -> Int {
 3         if s.isEmpty {return 0}
 4         let len:Int = s.count
 5         var dp:[Int] = [Int](repeating:1,count:len)
 6         var pre:Int,temp:Int
 7         for i in 0..<t.count
 8         {
 9             pre = dp[0]
10             dp[0] = (i == 0 && s[0] == t[0]) ? 1 : 0
11             for k in 1..<len
12             {
13                 temp = dp[k]
14                 dp[k] = dp[k - 1] + (s[k] == t[i] ? pre : 0)
15                 pre = temp
16             }
17         }
18         return dp[len - 1]
19     }
20 }
21 
22 extension String {
23     //subscript函式可以檢索陣列中的值
24     //直接按照索引方式擷取指定索引的字元
25     subscript (_ i: Int) -> Character {
26         //讀取字元
27         get {return self[index(startIndex, offsetBy: i)]}
28     }
29 }

超過時間限制

 1 class Solution {
 2     func numDistinct(_ s: String, _ t: String) -> Int {
 3         if s.isEmpty || t.isEmpty {return 0}
 4         //字串t的長度
 5         var len1:Int = t.count
 6         //字串s的長度
 7         var len2:Int = s.count
 8         //dp[i][j]表示從t的從0開始為i的子串和s的從0開始為j的子串的匹配個數。
 9         var dp:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:len2 + 1),count:len1 + 1)
10         
11         //首先i對於的就是字串t裡面的索引
12         for i in 0..<(len2+1)
13         {
14             dp[0][i]=1
15         }
16         
17         //首先從第二行開始計算，第一行中第一個數總是為1的。因為兩個空字串是匹配的
18         for i in 1..<(len1+1)
19         {
20             dp[i][0]=0
21         }
22         
23         //動態規劃
24         for i in 1...len1
25         {
26              //首先j對於的就是字串s裡面的索引。（s>t）
27             for j in 1...len2
28             {
29                 if t.charAt(i-1) == s.charAt(j-1)
30                 {
31                    dp[i][j] = dp[i-1][j-1]+dp[i][j-1]
32                 }
33                 else
34                 {
35                     dp[i][j] = dp[i][j-1]
36                 }
37             }
38         }
39         return dp[len1][len2]
40     }
41 }
42 
43 extension String {
44     //獲取指定索引位置的字元，返回為字串形式
45     func charAt(_ num:Int) -> Character
46     {
47         return self[index(self.startIndex,offsetBy: num)]
48     }
49 }