Skip to content

Commit 170fd23

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3335 (#4404)
No.3335.Total Characters in String After Transformations I
1 parent 356cd7b commit 170fd23

File tree

7 files changed

+376
-8
lines changed

7 files changed

+376
-8
lines changed

‎solution/3300-3399/3335.Total Characters in String After Transformations I/README.md

+134-4
Original file line numberDiff line numberDiff line change
@@ -112,32 +112,162 @@ tags:
112112

113113
<!-- solution:start -->
114114

115-
### 方法一
115+
### 方法一：递推
116+
117+
我们定义 $f[i][j]$ 表示经过 $i$ 次转换后，字母表中第 $j$ 个字母的个数。初始时 $f[0][j]$ 为字符串 $s$ 中字母表中第 $j$ 个字母的个数。
118+
119+
每次转换后，字母表中第 $j$ 个字母的个数可以通过以下方式计算：
120+
121+
$$
122+
\begin{align*}
123+
f[i][0] &= f[i - 1][25] \\
124+
f[i][1] &= f[i - 1][0] + f[i - 1][25] \\
125+
f[i][2] &= f[i - 1][1] \\
126+
f[i][3] &= f[i - 1][2] \\
127+
&\vdots \\
128+
f[i][25] &= f[i - 1][24]
129+
\end{align*}
130+
$$
131+
132+
答案为 $f[t][0] + f[t][1] + \ldots + f[t][25]$。
133+
134+
由于答案可能非常大，我们需要对 $10^9 + 7$ 取模。
135+
136+
时间复杂度 $O(t \times |\Sigma|)$，空间复杂度 $O(t \times |\Sigma|)$，其中 $|\Sigma|$ 为字母表的大小。
116137

117138
<!-- tabs:start -->
118139

119140
#### Python3
120141

121142
```python
122-
143+
class Solution:
144+
def lengthAfterTransformations(self, s: str, t: int) -> int:
145+
f = [[0] * 26 for _ in range(t + 1)]
146+
for c in s:
147+
f[0][ord(c) - ord("a")] += 1
148+
for i in range(1, t + 1):
149+
f[i][0] = f[i - 1][25]
150+
f[i][1] = f[i - 1][0] + f[i - 1][25]
151+
for j in range(2, 26):
152+
f[i][j] = f[i - 1][j - 1]
153+
mod = 10**9 + 7
154+
return sum(f[t]) % mod
123155
```
124156

125157
#### Java
126158

127159
```java
128-
160+
class Solution {
161+
public int lengthAfterTransformations(String s, int t) {
162+
final int mod = (int) 1e9 + 7;
163+
int[][] f = new int[t + 1][26];
164+
for (char c : s.toCharArray()) {
165+
f[0][c - 'a']++;
166+
}
167+
for (int i = 1; i <= t; ++i) {
168+
f[i][0] = f[i - 1][25] % mod;
169+
f[i][1] = (f[i - 1][0] + f[i - 1][25]) % mod;
170+
for (int j = 2; j < 26; j++) {
171+
f[i][j] = f[i - 1][j - 1] % mod;
172+
}
173+
}
174+
175+
int ans = 0;
176+
for (int j = 0; j < 26; ++j) {
177+
ans = (ans + f[t][j]) % mod;
178+
}
179+
return ans;
180+
}
181+
}
129182
```
130183

131184
#### C++
132185

133186
```cpp
134-
187+
class Solution {
188+
public:
189+
int lengthAfterTransformations(string s, int t) {
190+
const int mod = 1e9 + 7;
191+
vector<vector<int>> f(t + 1, vector<int>(26, 0));
192+
193+
for (char c : s) {
194+
f[0][c - 'a']++;
195+
}
196+
197+
for (int i = 1; i <= t; ++i) {
198+
f[i][0] = f[i - 1][25] % mod;
199+
f[i][1] = (f[i - 1][0] + f[i - 1][25]) % mod;
200+
for (int j = 2; j < 26; ++j) {
201+
f[i][j] = f[i - 1][j - 1] % mod;
202+
}
203+
}
204+
205+
int ans = 0;
206+
for (int j = 0; j < 26; ++j) {
207+
ans = (ans + f[t][j]) % mod;
208+
}
209+
210+
return ans;
211+
}
212+
};
135213
```
136214

137215
#### Go
138216

139217
```go
218+
func lengthAfterTransformations(s string, t int) int {
219+
const mod = 1_000_000_007
220+
f := make([][]int, t+1)
221+
for i := range f {
222+
f[i] = make([]int, 26)
223+
}
224+
225+
for _, c := range s {
226+
f[0][c-'a']++
227+
}
228+
229+
for i := 1; i <= t; i++ {
230+
f[i][0] = f[i-1][25] % mod
231+
f[i][1] = (f[i-1][0] + f[i-1][25]) % mod
232+
for j := 2; j < 26; j++ {
233+
f[i][j] = f[i-1][j-1] % mod
234+
}
235+
}
236+
237+
ans := 0
238+
for j := 0; j < 26; j++ {
239+
ans = (ans + f[t][j]) % mod
240+
}
241+
return ans
242+
}
243+
```
244+
245+
#### TypeScript
246+
247+
```ts
248+
function lengthAfterTransformations(s: string, t: number): number {
249+
const mod = 1_000_000_007;
250+
const f: number[][] = Array.from({ length: t + 1 }, () => Array(26).fill(0));
251+
252+
for (const c of s) {
253+
f[0][c.charCodeAt(0) - 'a'.charCodeAt(0)]++;
254+
}
255+
256+
for (let i = 1; i <= t; i++) {
257+
f[i][0] = f[i - 1][25] % mod;
258+
f[i][1] = (f[i - 1][0] + f[i - 1][25]) % mod;
259+
for (let j = 2; j < 26; j++) {
260+
f[i][j] = f[i - 1][j - 1] % mod;
261+
}
262+
}
263+
264+
let ans = 0;
265+
for (let j = 0; j < 26; j++) {
266+
ans = (ans + f[t][j]) % mod;
267+
}
140268

269+
return ans;
270+
}
141271
```
142272

143273
<!-- tabs:end -->

‎solution/3300-3399/3335.Total Characters in String After Transformations I/README_EN.md

+134-4
Original file line numberDiff line numberDiff line change
@@ -110,32 +110,162 @@ tags:
110110

111111
<!-- solution:start -->
112112

113-
### Solution 1
113+
### Solution 1: Recurrence
114+
115+
We define $f[i][j]$ to represent the count of the $j$-th letter in the alphabet after $i$ transformations. Initially, $f[0][j]$ is the count of the $j$-th letter in the string $s$.
116+
117+
After each transformation, the count of the $j$-th letter in the alphabet can be calculated as follows:
118+
119+
$$
120+
\begin{align*}
121+
f[i][0] &= f[i - 1][25] \\
122+
f[i][1] &= f[i - 1][0] + f[i - 1][25] \\
123+
f[i][2] &= f[i - 1][1] \\
124+
f[i][3] &= f[i - 1][2] \\
125+
&\vdots \\
126+
f[i][25] &= f[i - 1][24]
127+
\end{align*}
128+
$$
129+
130+
The answer is $f[t][0] + f[t][1] + \ldots + f[t][25]$.
131+
132+
Since the answer can be very large, we take the result modulo $10^9 + 7$.
133+
134+
The time complexity is $O(t \times |\Sigma|)$, and the space complexity is $O(t \times |\Sigma|)$, where $|\Sigma|$ is the size of the alphabet.
114135

115136
<!-- tabs:start -->
116137

117138
#### Python3
118139

119140
```python
120-
141+
class Solution:
142+
def lengthAfterTransformations(self, s: str, t: int) -> int:
143+
f = [[0] * 26 for _ in range(t + 1)]
144+
for c in s:
145+
f[0][ord(c) - ord("a")] += 1
146+
for i in range(1, t + 1):
147+
f[i][0] = f[i - 1][25]
148+
f[i][1] = f[i - 1][0] + f[i - 1][25]
149+
for j in range(2, 26):
150+
f[i][j] = f[i - 1][j - 1]
151+
mod = 10**9 + 7
152+
return sum(f[t]) % mod
121153
```
122154

123155
#### Java
124156

125157
```java
126-
158+
class Solution {
159+
public int lengthAfterTransformations(String s, int t) {
160+
final int mod = (int) 1e9 + 7;
161+
int[][] f = new int[t + 1][26];
162+
for (char c : s.toCharArray()) {
163+
f[0][c - 'a']++;
164+
}
165+
for (int i = 1; i <= t; ++i) {
166+
f[i][0] = f[i - 1][25] % mod;
167+
f[i][1] = (f[i - 1][0] + f[i - 1][25]) % mod;
168+
for (int j = 2; j < 26; j++) {
169+
f[i][j] = f[i - 1][j - 1] % mod;
170+
}
171+
}
172+
173+
int ans = 0;
174+
for (int j = 0; j < 26; ++j) {
175+
ans = (ans + f[t][j]) % mod;
176+
}
177+
return ans;
178+
}
179+
}
127180
```
128181

129182
#### C++
130183

131184
```cpp
132-
185+
class Solution {
186+
public:
187+
int lengthAfterTransformations(string s, int t) {
188+
const int mod = 1e9 + 7;
189+
vector<vector<int>> f(t + 1, vector<int>(26, 0));
190+
191+
for (char c : s) {
192+
f[0][c - 'a']++;
193+
}
194+
195+
for (int i = 1; i <= t; ++i) {
196+
f[i][0] = f[i - 1][25] % mod;
197+
f[i][1] = (f[i - 1][0] + f[i - 1][25]) % mod;
198+
for (int j = 2; j < 26; ++j) {
199+
f[i][j] = f[i - 1][j - 1] % mod;
200+
}
201+
}
202+
203+
int ans = 0;
204+
for (int j = 0; j < 26; ++j) {
205+
ans = (ans + f[t][j]) % mod;
206+
}
207+
208+
return ans;
209+
}
210+
};
133211
```
134212

135213
#### Go
136214

137215
```go
216+
func lengthAfterTransformations(s string, t int) int {
217+
const mod = 1_000_000_007
218+
f := make([][]int, t+1)
219+
for i := range f {
220+
f[i] = make([]int, 26)
221+
}
222+
223+
for _, c := range s {
224+
f[0][c-'a']++
225+
}
226+
227+
for i := 1; i <= t; i++ {
228+
f[i][0] = f[i-1][25] % mod
229+
f[i][1] = (f[i-1][0] + f[i-1][25]) % mod
230+
for j := 2; j < 26; j++ {
231+
f[i][j] = f[i-1][j-1] % mod
232+
}
233+
}
234+
235+
ans := 0
236+
for j := 0; j < 26; j++ {
237+
ans = (ans + f[t][j]) % mod
238+
}
239+
return ans
240+
}
241+
```
242+
243+
#### TypeScript
244+
245+
```ts
246+
function lengthAfterTransformations(s: string, t: number): number {
247+
const mod = 1_000_000_007;
248+
const f: number[][] = Array.from({ length: t + 1 }, () => Array(26).fill(0));
249+
250+
for (const c of s) {
251+
f[0][c.charCodeAt(0) - 'a'.charCodeAt(0)]++;
252+
}
253+
254+
for (let i = 1; i <= t; i++) {
255+
f[i][0] = f[i - 1][25] % mod;
256+
f[i][1] = (f[i - 1][0] + f[i - 1][25]) % mod;
257+
for (let j = 2; j < 26; j++) {
258+
f[i][j] = f[i - 1][j - 1] % mod;
259+
}
260+
}
261+
262+
let ans = 0;
263+
for (let j = 0; j < 26; j++) {
264+
ans = (ans + f[t][j]) % mod;
265+
}
138266

267+
return ans;
268+
}
139269
```
140270

141271
<!-- tabs:end -->

‎solution/3300-3399/3335.Total Characters in String After Transformations I/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
int lengthAfterTransformations(string s, int t) {
4+
const int mod = 1e9 + 7;
5+
vector<vector<int>> f(t + 1, vector<int>(26, 0));
6+
7+
for (char c : s) {
8+
f[0][c - 'a']++;
9+
}
10+
11+
for (int i = 1; i <= t; ++i) {
12+
f[i][0] = f[i - 1][25] % mod;
13+
f[i][1] = (f[i - 1][0] + f[i - 1][25]) % mod;
14+
for (int j = 2; j < 26; ++j) {
15+
f[i][j] = f[i - 1][j - 1] % mod;
16+
}
17+
}
18+
19+
int ans = 0;
20+
for (int j = 0; j < 26; ++j) {
21+
ans = (ans + f[t][j]) % mod;
22+
}
23+
24+
return ans;
25+
}
26+
};

‎solution/3300-3399/3335.Total Characters in String After Transformations I/Solution.go

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
func lengthAfterTransformations(s string, t int) int {
2+
const mod = 1_000_000_007
3+
f := make([][]int, t+1)
4+
for i := range f {
5+
f[i] = make([]int, 26)
6+
}
7+
8+
for _, c := range s {
9+
f[0][c-'a']++
10+
}
11+
12+
for i := 1; i <= t; i++ {
13+
f[i][0] = f[i-1][25] % mod
14+
f[i][1] = (f[i-1][0] + f[i-1][25]) % mod
15+
for j := 2; j < 26; j++ {
16+
f[i][j] = f[i-1][j-1] % mod
17+
}
18+
}
19+
20+
ans := 0
21+
for j := 0; j < 26; j++ {
22+
ans = (ans + f[t][j]) % mod
23+
}
24+
return ans
25+
}

0 commit comments

Comments
 (0)