From 57be2fa8512c0c6fbca45f09212257576cb7251e Mon Sep 17 00:00:00 2001 From: yanglbme Date: Wed, 2 Jul 2025 07:27:38 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.3333 No.3333.Find the Original Typed String II --- .../README.md | 235 +++++++++++++++++- .../README_EN.md | 235 +++++++++++++++++- .../Solution.cpp | 51 ++++ .../Solution.go | 54 ++++ .../Solution.java | 50 ++++ .../Solution.py | 25 ++ .../Solution.ts | 48 ++++ 7 files changed, 692 insertions(+), 6 deletions(-) create mode 100644 solution/3300-3399/3333.Find the Original Typed String II/Solution.cpp create mode 100644 solution/3300-3399/3333.Find the Original Typed String II/Solution.go create mode 100644 solution/3300-3399/3333.Find the Original Typed String II/Solution.java create mode 100644 solution/3300-3399/3333.Find the Original Typed String II/Solution.py create mode 100644 solution/3300-3399/3333.Find the Original Typed String II/Solution.ts diff --git a/solution/3300-3399/3333.Find the Original Typed String II/README.md b/solution/3300-3399/3333.Find the Original Typed String II/README.md index 2f146eea6be79..8244b18474e98 100644 --- a/solution/3300-3399/3333.Find the Original Typed String II/README.md +++ b/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 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 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> f(m + 1, vector(k, 0)); + f[0][0] = 1; + + for (int i = 1; i <= m; ++i) { + int x = nums[i - 1]; + vector 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; +} ``` diff --git a/solution/3300-3399/3333.Find the Original Typed String II/README_EN.md b/solution/3300-3399/3333.Find the Original Typed String II/README_EN.md index 88fd2da02fb2c..3ddd4a5eb4420 100644 --- a/solution/3300-3399/3333.Find the Original Typed String II/README_EN.md +++ b/solution/3300-3399/3333.Find the Original Typed String II/README_EN.md @@ -83,25 +83,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 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 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> f(m + 1, vector(k, 0)); + f[0][0] = 1; + + for (int i = 1; i <= m; ++i) { + int x = nums[i - 1]; + vector 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; +} ``` diff --git a/solution/3300-3399/3333.Find the Original Typed String II/Solution.cpp b/solution/3300-3399/3333.Find the Original Typed String II/Solution.cpp new file mode 100644 index 0000000000000..1dfc03aaf3469 --- /dev/null +++ b/solution/3300-3399/3333.Find the Original Typed String II/Solution.cpp @@ -0,0 +1,51 @@ +class Solution { +public: + int possibleStringCount(string word, int k) { + const int mod = 1e9 + 7; + vector 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> f(m + 1, vector(k, 0)); + f[0][0] = 1; + + for (int i = 1; i <= m; ++i) { + int x = nums[i - 1]; + vector 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; + } +}; diff --git a/solution/3300-3399/3333.Find the Original Typed String II/Solution.go b/solution/3300-3399/3333.Find the Original Typed String II/Solution.go new file mode 100644 index 0000000000000..5fd17b48b1808 --- /dev/null +++ b/solution/3300-3399/3333.Find the Original Typed String II/Solution.go @@ -0,0 +1,54 @@ +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 +} diff --git a/solution/3300-3399/3333.Find the Original Typed String II/Solution.java b/solution/3300-3399/3333.Find the Original Typed String II/Solution.java new file mode 100644 index 0000000000000..f435f834d61ee --- /dev/null +++ b/solution/3300-3399/3333.Find the Original Typed String II/Solution.java @@ -0,0 +1,50 @@ +class Solution { + public int possibleStringCount(String word, int k) { + final int mod = (int) 1e9 + 7; + List 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); + } +} diff --git a/solution/3300-3399/3333.Find the Original Typed String II/Solution.py b/solution/3300-3399/3333.Find the Original Typed String II/Solution.py new file mode 100644 index 0000000000000..d756c1a7b4542 --- /dev/null +++ b/solution/3300-3399/3333.Find the Original Typed String II/Solution.py @@ -0,0 +1,25 @@ +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 diff --git a/solution/3300-3399/3333.Find the Original Typed String II/Solution.ts b/solution/3300-3399/3333.Find the Original Typed String II/Solution.ts new file mode 100644 index 0000000000000..e8a6f3ce8d1f9 --- /dev/null +++ b/solution/3300-3399/3333.Find the Original Typed String II/Solution.ts @@ -0,0 +1,48 @@ +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; +}