Add solution 115

Author: halfrost

README.md

@@ -0,0 +1,45 @@
+package leetcode
+
+// 解法一 压缩版 DP
+func numDistinct(s string, t string) int {
+	dp := make([]int, len(s)+1)
+	for i, curT := range t {
+		pre := 0
+		for j, curS := range s {
+			if i == 0 {
+				pre = 1
+			}
+			newDP := dp[j+1]
+			if curT == curS {
+				dp[j+1] = dp[j] + pre
+			} else {
+				dp[j+1] = dp[j]
+			}
+			pre = newDP
+		}
+	}
+	return dp[len(s)]
+}
+
+// 解法二 普通 DP
+func numDistinct1(s, t string) int {
+	m, n := len(s), len(t)
+	if m < n {
+		return 0
+	}
+	dp := make([][]int, m+1)
+	for i := range dp {
+		dp[i] = make([]int, n+1)
+		dp[i][n] = 1
+	}
+	for i := m - 1; i >= 0; i-- {
+		for j := n - 1; j >= 0; j-- {
+			if s[i] == t[j] {
+				dp[i][j] = dp[i+1][j+1] + dp[i+1][j]
+			} else {
+				dp[i][j] = dp[i+1][j]
+			}
+		}
+	}
+	return dp[0][0]
+}

leetcode/0115.Distinct-Subsequences/115. Distinct Subsequences.go

@@ -0,0 +1,48 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question115 struct {
+	para115
+	ans115
+}
+
+// para 是参数
+// one 代表第一个参数
+type para115 struct {
+	s string
+	t string
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans115 struct {
+	one int
+}
+
+func Test_Problem115(t *testing.T) {
+
+	qs := []question115{
+
+		{
+			para115{"rabbbit", "rabbit"},
+			ans115{3},
+		},
+
+		{
+			para115{"babgbag", "bag"},
+			ans115{5},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 115------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans115, q.para115
+		fmt.Printf("【input】:%v       【output】:%v\n", p, numDistinct(p.s, p.t))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/0115.Distinct-Subsequences/115. Distinct Subsequences_test.go

@@ -0,0 +1,101 @@
+# [115. Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/)
+
+
+## 题目
+
+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).
+
+It is guaranteed the answer fits on a 32-bit signed integer.
+
+**Example 1:**
+
+```
+Input: s = "rabbbit", t = "rabbit"
+Output: 3
+Explanation:
+As shown below, there are 3 ways you can generate "rabbit" from S.
+rabbbitrabbbitrabbbit
+```
+
+**Example 2:**
+
+```
+Input: s = "babgbag", t = "bag"
+Output: 5
+Explanation:
+As shown below, there are 5 ways you can generate "bag" from S.
+babgbagbabgbagbabgbagbabgbagbabgbag
+```
+
+**Constraints:**
+
+- `0 <= s.length, t.length <= 1000`
+- `s` and `t` consist of English letters.
+
+## 题目大意
+
+给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）题目数据保证答案符合 32 位带符号整数范围。
+
+## 解题思路
+
+- 在字符串 `s` 中最多包含多少个字符串 `t`。这里面包含很多重叠子问题，所以尝试用动态规划解决这个问题。定义 `dp[i][j]` 代表 `s[i:]` 的子序列中 `t[j:]` 出现的个数。初始化先判断边界条件。当 `i = len(s)` 且 `0≤ j < len(t)` 的时候，`s[i:]` 为空字符串，`t[j:]` 不为空，所以 `dp[len(s)][j] = 0`。当 `j = len(t)` 且 `0 ≤ i < len(s)` 的时候，`t[j:]` 不为空字符串，空字符串是任何字符串的子序列。所以 `dp[i][n] = 1`。
+- 当 `i < len(s)` 且 `j < len(t)` 的时候，如果 `s[i] == t[j]`，有 2 种匹配方式，第一种将 `s[i]` 与 `t[j]` 匹配，那么 `t[j+1:]` 匹配 `s[i+1:]` 的子序列，子序列数为 `dp[i+1][j+1]`；第二种将 `s[i]` 不与 `t[j]` 匹配，`t[j:]` 作为 `s[i+1:]` 的子序列，子序列数为 `dp[i+1][j]`。综合 2 种情况，当 `s[i] == t[j]` 时，`dp[i][j] = dp[i+1][j+1] + dp[i+1][j]`。
+- 如果 `s[i] != t[j]`，此时 `t[j:]` 只能作为 `s[i+1:]` 的子序列，子序列数为 `dp[i+1][j]`。所以当 `s[i] != t[j]` 时，`dp[i][j] = dp[i+1][j]`。综上分析得：
+
+	{{< katex display >}}
+    dp[i][j] = \left\{\begin{matrix}dp[i+1][j+1]+dp[i+1][j]&,s[i]=t[j]\\ dp[i+1][j]&,s[i]!=t[j]\end{matrix}\right.
+	{{< /katex >}}
+
+- 最后是优化版本。写出上述代码以后，可以发现填表的过程是从右下角一直填到左上角。填表顺序是 从下往上一行一行的填。行内从右往左填。于是可以将这个二维数据压缩到一维。因为填充当前行只需要用到它的下一行信息即可，更进一步，用到的是下一行中右边元素的信息。于是可以每次更新该行时，先将旧的值存起来，计算更新该行的时候从右往左更新。这样做即可减少一维空间，将原来的二维数组压缩到一维数组。
+
+## 代码
+
+```go
+package leetcode
+
+// 解法一 压缩版 DP
+func numDistinct(s string, t string) int {
+	dp := make([]int, len(s)+1)
+	for i, curT := range t {
+		pre := 0
+		for j, curS := range s {
+			if i == 0 {
+				pre = 1
+			}
+			newDP := dp[j+1]
+			if curT == curS {
+				dp[j+1] = dp[j] + pre
+			} else {
+				dp[j+1] = dp[j]
+			}
+			pre = newDP
+		}
+	}
+	return dp[len(s)]
+}
+
+// 解法二 普通 DP
+func numDistinct1(s, t string) int {
+	m, n := len(s), len(t)
+	if m < n {
+		return 0
+	}
+	dp := make([][]int, m+1)
+	for i := range dp {
+		dp[i] = make([]int, n+1)
+		dp[i][n] = 1
+	}
+	for i := m - 1; i >= 0; i-- {
+		for j := n - 1; j >= 0; j-- {
+			if s[i] == t[j] {
+				dp[i][j] = dp[i+1][j+1] + dp[i+1][j]
+			} else {
+				dp[i][j] = dp[i+1][j]
+			}
+		}
+	}
+	return dp[0][0]
+}
+```

leetcode/0115.Distinct-Subsequences/README.md

@@ -194,5 +194,5 @@ func flatten2(root *TreeNode) {
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0113.Path-Sum-II/">⬅️上一页</a></p>
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0118.Pascals-Triangle/">下一页➡️</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0115.Distinct-Subsequences/">下一页➡️</a></p>
 </div>

website/content/ChapterFour/0100~0199/0114.Flatten-Binary-Tree-to-Linked-List.md

@@ -0,0 +1,106 @@
+# [115. Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/)
+
+
+## 题目
+
+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).
+
+It is guaranteed the answer fits on a 32-bit signed integer.
+
+**Example 1:**
+
+```
+Input: s = "rabbbit", t = "rabbit"
+Output: 3
+Explanation:
+As shown below, there are 3 ways you can generate "rabbit" from S.
+rabbbitrabbbitrabbbit
+```
+
+**Example 2:**
+
+```
+Input: s = "babgbag", t = "bag"
+Output: 5
+Explanation:
+As shown below, there are 5 ways you can generate "bag" from S.
+babgbagbabgbagbabgbagbabgbagbabgbag
+```
+
+**Constraints:**
+
+- `0 <= s.length, t.length <= 1000`
+- `s` and `t` consist of English letters.
+
+## 题目大意
+
+给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）题目数据保证答案符合 32 位带符号整数范围。
+
+## 解题思路
+
+- 在字符串 `s` 中最多包含多少个字符串 `t`。这里面包含很多重叠子问题，所以尝试用动态规划解决这个问题。定义 `dp[i][j]` 代表 `s[i:]` 的子序列中 `t[j:]` 出现的个数。初始化先判断边界条件。当 `i = len(s)` 且 `0≤ j < len(t)` 的时候，`s[i:]` 为空字符串，`t[j:]` 不为空，所以 `dp[len(s)][j] = 0`。当 `j = len(t)` 且 `0 ≤ i < len(s)` 的时候，`t[j:]` 不为空字符串，空字符串是任何字符串的子序列。所以 `dp[i][n] = 1`。
+- 当 `i < len(s)` 且 `j < len(t)` 的时候，如果 `s[i] == t[j]`，有 2 种匹配方式，第一种将 `s[i]` 与 `t[j]` 匹配，那么 `t[j+1:]` 匹配 `s[i+1:]` 的子序列，子序列数为 `dp[i+1][j+1]`；第二种将 `s[i]` 不与 `t[j]` 匹配，`t[j:]` 作为 `s[i+1:]` 的子序列，子序列数为 `dp[i+1][j]`。综合 2 种情况，当 `s[i] == t[j]` 时，`dp[i][j] = dp[i+1][j+1] + dp[i+1][j]`。
+- 如果 `s[i] != t[j]`，此时 `t[j:]` 只能作为 `s[i+1:]` 的子序列，子序列数为 `dp[i+1][j]`。所以当 `s[i] != t[j]` 时，`dp[i][j] = dp[i+1][j]`。综上分析得：
+
+    $$dp[i][j] = \left\{\begin{matrix}dp[i+1][j+1]+dp[i+1][j]&,s[i]=t[j]\\ dp[i+1][j]&,s[i]!=t[j]\end{matrix}\right.$$
+
+- 最后是优化版本。写出上述代码以后，可以发现填表的过程是从右下角一直填到左上角。填表顺序是 从下往上一行一行的填。行内从右往左填。于是可以将这个二维数据压缩到一维。因为填充当前行只需要用到它的下一行信息即可，更进一步，用到的是下一行中右边元素的信息。于是可以每次更新该行时，先将旧的值存起来，计算更新该行的时候从右往左更新。这样做即可减少一维空间，将原来的二维数组压缩到一维数组。
+
+## 代码
+
+```go
+package leetcode
+
+// 解法一 压缩版 DP
+func numDistinct(s string, t string) int {
+	dp := make([]int, len(s)+1)
+	for i, curT := range t {
+		pre := 0
+		for j, curS := range s {
+			if i == 0 {
+				pre = 1
+			}
+			newDP := dp[j+1]
+			if curT == curS {
+				dp[j+1] = dp[j] + pre
+			} else {
+				dp[j+1] = dp[j]
+			}
+			pre = newDP
+		}
+	}
+	return dp[len(s)]
+}
+
+// 解法二 普通 DP
+func numDistinct1(s, t string) int {
+	m, n := len(s), len(t)
+	if m < n {
+		return 0
+	}
+	dp := make([][]int, m+1)
+	for i := range dp {
+		dp[i] = make([]int, n+1)
+		dp[i][n] = 1
+	}
+	for i := m - 1; i >= 0; i-- {
+		for j := n - 1; j >= 0; j-- {
+			if s[i] == t[j] {
+				dp[i][j] = dp[i+1][j+1] + dp[i+1][j]
+			} else {
+				dp[i][j] = dp[i+1][j]
+			}
+		}
+	}
+	return dp[0][0]
+}
+```
+
+
+----------------------------------------------
+<div style="display: flex;justify-content: space-between;align-items: center;">
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0114.Flatten-Binary-Tree-to-Linked-List/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0118.Pascals-Triangle/">下一页➡️</a></p>
+</div>

website/content/ChapterFour/0100~0199/0115.Distinct-Subsequences.md

@@ -62,6 +62,6 @@ func generate(numRows int) [][]int {
 
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0114.Flatten-Binary-Tree-to-Linked-List/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0115.Distinct-Subsequences/">⬅️上一页</a></p>
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0119.Pascals-Triangle-II/">下一页➡️</a></p>
 </div>