feat: add solutions to lc problem: No.3333

No.3333.Find the Original Typed String II

Author: yanglbme

solution/3300-3399/3333.Find the Original Typed String II/README.md

@@ -86,25 +86,254 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def possibleStringCount(self, word: str, k: int) -> int:
+        mod = 10**9 + 7
+        nums = []
+        ans = 1
+        cur = 0
+        for i, c in enumerate(word):
+            cur += 1
+            if i == len(word) - 1 or c != word[i + 1]:
+                if cur > 1:
+                    if k > 0:
+                        nums.append(cur - 1)
+                    ans = ans * cur % mod
+                cur = 0
+                k -= 1
+        if k < 1:
+            return ans
+        m = len(nums)
+        f = [[0] * k for _ in range(m + 1)]
+        f[0][0] = 1
+        for i, x in enumerate(nums, 1):
+            s = list(accumulate(f[i - 1], initial=0))
+            for j in range(k):
+                f[i][j] = (s[j + 1] - s[j - min(x, j)] + mod) % mod
+        return (ans - sum(f[m][j] for j in range(k))) % mod
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int possibleStringCount(String word, int k) {
+        final int mod = (int) 1e9 + 7;
+        List<Integer> nums = new ArrayList<>();
+        long ans = 1;
+        int cur = 0;
+        int n = word.length();
+
+        for (int i = 0; i < n; i++) {
+            cur++;
+            if (i == n - 1 || word.charAt(i) != word.charAt(i + 1)) {
+                if (cur > 1) {
+                    if (k > 0) {
+                        nums.add(cur - 1);
+                    }
+                    ans = ans * cur % mod;
+                }
+                cur = 0;
+                k--;
+            }
+        }
+
+        if (k < 1) {
+            return (int) ans;
+        }
+
+        int m = nums.size();
+        int[][] f = new int[m + 1][k];
+        f[0][0] = 1;
+
+        for (int i = 1; i <= m; i++) {
+            int x = nums.get(i - 1);
+            long[] s = new long[k + 1];
+            for (int j = 0; j < k; j++) {
+                s[j + 1] = (s[j] + f[i - 1][j]) % mod;
+            }
+            for (int j = 0; j < k; j++) {
+                int l = Math.max(0, j - x);
+                f[i][j] = (int) ((s[j + 1] - s[l] + mod) % mod);
+            }
+        }
+
+        long sum = 0;
+        for (int j = 0; j < k; j++) {
+            sum = (sum + f[m][j]) % mod;
+        }
+
+        return (int) ((ans - sum + mod) % mod);
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int possibleStringCount(string word, int k) {
+        const int mod = 1e9 + 7;
+        vector<int> nums;
+        long long ans = 1;
+        int cur = 0;
+        int n = word.size();
+
+        for (int i = 0; i < n; ++i) {
+            cur++;
+            if (i == n - 1 || word[i] != word[i + 1]) {
+                if (cur > 1) {
+                    if (k > 0) {
+                        nums.push_back(cur - 1);
+                    }
+                    ans = ans * cur % mod;
+                }
+                cur = 0;
+                k--;
+            }
+        }
+
+        if (k < 1) {
+            return ans;
+        }
+
+        int m = nums.size();
+        vector<vector<int>> f(m + 1, vector<int>(k, 0));
+        f[0][0] = 1;
+
+        for (int i = 1; i <= m; ++i) {
+            int x = nums[i - 1];
+            vector<long long> s(k + 1, 0);
+            for (int j = 0; j < k; ++j) {
+                s[j + 1] = (s[j] + f[i - 1][j]) % mod;
+            }
+            for (int j = 0; j < k; ++j) {
+                int l = max(0, j - x);
+                f[i][j] = (s[j + 1] - s[l] + mod) % mod;
+            }
+        }
+
+        long long sum = 0;
+        for (int j = 0; j < k; ++j) {
+            sum = (sum + f[m][j]) % mod;
+        }
+
+        return (ans - sum + mod) % mod;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func possibleStringCount(word string, k int) int {
+	const mod = 1_000_000_007
+	nums := []int{}
+	ans := 1
+	cur := 0
+	n := len(word)
+
+	for i := 0; i < n; i++ {
+		cur++
+		if i == n-1 || word[i] != word[i+1] {
+			if cur > 1 {
+				if k > 0 {
+					nums = append(nums, cur-1)
+				}
+				ans = ans * cur % mod
+			}
+			cur = 0
+			k--
+		}
+	}
+
+	if k < 1 {
+		return ans
+	}
+
+	m := len(nums)
+	f := make([][]int, m+1)
+	for i := range f {
+		f[i] = make([]int, k)
+	}
+	f[0][0] = 1
+
+	for i := 1; i <= m; i++ {
+		x := nums[i-1]
+		s := make([]int, k+1)
+		for j := 0; j < k; j++ {
+			s[j+1] = (s[j] + f[i-1][j]) % mod
+		}
+		for j := 0; j < k; j++ {
+			l := j - x
+			if l < 0 {
+				l = 0
+			}
+			f[i][j] = (s[j+1] - s[l] + mod) % mod
+		}
+	}
+
+	sum := 0
+	for j := 0; j < k; j++ {
+		sum = (sum + f[m][j]) % mod
+	}
+
+	return (ans - sum + mod) % mod
+}
+```
 
+#### TypeScript
+
+```ts
+function possibleStringCount(word: string, k: number): number {
+    const mod = 1_000_000_007;
+    const nums: number[] = [];
+    let ans = 1;
+    let cur = 0;
+    const n = word.length;
+
+    for (let i = 0; i < n; i++) {
+        cur++;
+        if (i === n - 1 || word[i] !== word[i + 1]) {
+            if (cur > 1) {
+                if (k > 0) {
+                    nums.push(cur - 1);
+                }
+                ans = (ans * cur) % mod;
+            }
+            cur = 0;
+            k--;
+        }
+    }
+
+    if (k < 1) {
+        return ans;
+    }
+
+    const m = nums.length;
+    const f: number[][] = Array.from({ length: m + 1 }, () => Array(k).fill(0));
+    f[0][0] = 1;
+
+    for (let i = 1; i <= m; i++) {
+        const x = nums[i - 1];
+        const s: number[] = Array(k + 1).fill(0);
+        for (let j = 0; j < k; j++) {
+            s[j + 1] = (s[j] + f[i - 1][j]) % mod;
+        }
+        for (let j = 0; j < k; j++) {
+            const l = Math.max(0, j - x);
+            f[i][j] = (s[j + 1] - s[l] + mod) % mod;
+        }
+    }
+
+    let sum = 0;
+    for (let j = 0; j < k; j++) {
+        sum = (sum + f[m][j]) % mod;
+    }
+
+    return (ans - sum + mod) % mod;
+}
 ```
 
 <!-- tabs:end -->