feat: add solutions to lc problem: No.1639

No.1639.Number of Ways to Form a Target String Given a Dictionary

Author: yanglbme

solution/1600-1699/1639.Number of Ways to Form a Target String Given a Dictionary/README.md

@@ -97,6 +97,18 @@
 
 时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 为字符串 $target$ 的长度，而 $n$ 为字符串数组 $words$ 中每个字符串的长度。
 
+**方法二：预处理 + 动态规划**
+
+与方法一类似，我们可以先预处理出一个二维数组 $cnt$，其中 $cnt[j][c]$ 表示字符串数组 $words$ 中第 $j$ 个位置的字符 $c$ 的数量。
+
+接下来，我们定义 $f[i][j]$ 表示构造 $target$ 的前 $i$ 个字符，且当前是从 $words$ 中每个单词的前 $j$ 个字符中选取字符的方案数。那么答案就是 $f[m][n]$。初始时 $f[0][j] = 1$，其中 $0 \leq j \leq n$。
+
+考虑 $f[i][j]$，其中 $i \gt 0$, $j \gt 0$。我们可以不选取 $words$ 中的第 $j$ 个位置的字符，那么方案数为 $f[i][j - 1]$；或者我们选择 $words$ 中的第 $j$ 个位置的字符，那么方案数为 $f[i - 1][j - 1] \times cnt[j - 1][target[i - 1] - 'a']$。最后，我们将这两种情况的方案数相加，即为 $f[i][j]$ 的值。
+
+最后，我们返回 $f[m][n]$ 即可。注意答案的取模操作。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 为字符串 $target$ 的长度，而 $n$ 为字符串数组 $words$ 中每个字符串的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -107,25 +119,42 @@
 class Solution:
     def numWays(self, words: List[str], target: str) -> int:
         @cache
-        def dfs(i, j):
+        def dfs(i: int, j: int) -> int:
             if i >= m:
                 return 1
             if j >= n:
                 return 0
-            ans = dfs(i, j + 1) + dfs(i + 1, j + 1) * cnt[j][ord(target[i]) - ord("a")]
-            ans %= mod
+            ans = dfs(i + 1, j + 1) * cnt[j][ord(target[i]) - ord('a')]
+            ans = (ans + dfs(i, j + 1)) % mod
             return ans
 
-        m = len(target)
-        n = len(words[0])
+        m, n = len(target), len(words[0])
         cnt = [[0] * 26 for _ in range(n)]
         for w in words:
             for j, c in enumerate(w):
-                cnt[j][ord(c) - ord("a")] += 1
+                cnt[j][ord(c) - ord('a')] += 1
         mod = 10**9 + 7
         return dfs(0, 0)
 ```
 
+```python
+class Solution:
+    def numWays(self, words: List[str], target: str) -> int:
+        m, n = len(target), len(words[0])
+        cnt = [[0] * 26 for _ in range(n)]
+        for w in words:
+            for j, c in enumerate(w):
+                cnt[j][ord(c) - ord('a')] += 1
+        mod = 10**9 + 7
+        f = [[0] * (n + 1) for _ in range(m + 1)]
+        f[0] = [1] * (n + 1)
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                f[i][j] = f[i][j - 1] + f[i - 1][j - 1] * cnt[j - 1][ord(target[i - 1]) - ord('a')]
+                f[i][j] %= mod
+        return f[m][n]
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -171,6 +200,31 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int numWays(String[] words, String target) {
+        int m = target.length();
+        int n = words[0].length();
+        final int mod = (int) 1e9 + 7;
+        long[][] f = new long[m + 1][n + 1];
+        Arrays.fill(f[0], 1);
+        int[][] cnt = new int[n][26];
+        for (var w : words) {
+            for (int j = 0; j < n; ++j) {
+                cnt[j][w.charAt(j) - 'a']++;
+            }
+        }
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                f[i][j] = f[i][j - 1] + f[i - 1][j - 1] * cnt[j - 1][target.charAt(i - 1) - 'a'];
+                f[i][j] %= mod;
+            }
+        }
+        return (int) f[m][n];
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -206,6 +260,32 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int numWays(vector<string>& words, string target) {
+        int m = target.size(), n = words[0].size();
+        const int mod = 1e9 + 7;
+        long long f[m + 1][n + 1];
+        memset(f, 0, sizeof(f));
+        fill(f[0], f[0] + n + 1, 1);
+        vector<vector<int>> cnt(n, vector<int>(26));
+        for (auto& w : words) {
+            for (int j = 0; j < n; ++j) {
+                ++cnt[j][w[j] - 'a'];
+            }
+        }
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                f[i][j] = f[i][j - 1] + f[i - 1][j - 1] * cnt[j - 1][target[i - 1] - 'a'];
+                f[i][j] %= mod;
+            }
+        }
+        return f[m][n];
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -245,6 +325,62 @@ func numWays(words []string, target string) int {
 }
 ```
 
+```go
+func numWays(words []string, target string) int {
+	const mod = 1e9 + 7
+	m, n := len(target), len(words[0])
+	f := make([][]int, m+1)
+	for i := range f {
+		f[i] = make([]int, n+1)
+	}
+	for j := range f[0] {
+		f[0][j] = 1
+	}
+	cnt := make([][26]int, n)
+	for _, w := range words {
+		for j, c := range w {
+			cnt[j][c-'a']++
+		}
+	}
+	for i := 1; i <= m; i++ {
+		for j := 1; j <= n; j++ {
+			f[i][j] = f[i][j-1] + f[i-1][j-1]*cnt[j-1][target[i-1]-'a']
+			f[i][j] %= mod
+		}
+	}
+	return f[m][n]
+}
+```
+
+### **TypeScript**
+
+```ts
+function numWays(words: string[], target: string): number {
+    const m = target.length;
+    const n = words[0].length;
+    const f = new Array(m + 1).fill(0).map(() => new Array(n + 1).fill(0));
+    const mod = 1e9 + 7;
+    for (let j = 0; j <= n; ++j) {
+        f[0][j] = 1;
+    }
+    const cnt = new Array(n).fill(0).map(() => new Array(26).fill(0));
+    for (const w of words) {
+        for (let j = 0; j < n; ++j) {
+            ++cnt[j][w.charCodeAt(j) - 97];
+        }
+    }
+    for (let i = 1; i <= m; ++i) {
+        for (let j = 1; j <= n; ++j) {
+            f[i][j] =
+                f[i][j - 1] +
+                f[i - 1][j - 1] * cnt[j - 1][target.charCodeAt(i - 1) - 97];
+            f[i][j] %= mod;
+        }
+    }
+    return f[m][n];
+}
+```
+
 ### **...**
 
 ```