Skip to content

Commit eea38bc

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.3405
No.3405.Count the Number of Arrays with K Matching Adjacent Elements
1 parent c520c5a commit eea38bc

File tree

7 files changed

+471
-4
lines changed

7 files changed

+471
-4
lines changed

‎solution/3400-3499/3405.Count the Number of Arrays with K Matching Adjacent Elements/README.md

Lines changed: 158 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -101,25 +101,181 @@ tags:
101101
#### Python3
102102

103103
```python
104+
mx = 10**5 + 10
105+
mod = 10**9 + 7
106+
f = [1] + [0] * mx
107+
g = [1] + [0] * mx
104108

109+
for i in range(1, mx):
110+
f[i] = f[i - 1] * i % mod
111+
g[i] = pow(f[i], mod - 2, mod)
112+
113+
114+
def comb(m: int, n: int) -> int:
115+
return f[m] * g[n] * g[m - n] % mod
116+
117+
118+
class Solution:
119+
def countGoodArrays(self, n: int, m: int, k: int) -> int:
120+
return comb(n - 1, k) * m * pow(m - 1, n - k - 1, mod) % mod
105121
```
106122

107123
#### Java
108124

109125
```java
110-
126+
class Solution {
127+
private static final int N = (int) 1e5 + 10;
128+
private static final int MOD = (int) 1e9 + 7;
129+
private static final long[] f = new long[N];
130+
private static final long[] g = new long[N];
131+
132+
static {
133+
f[0] = 1;
134+
g[0] = 1;
135+
for (int i = 1; i < N; ++i) {
136+
f[i] = f[i - 1] * i % MOD;
137+
g[i] = qpow(f[i], MOD - 2);
138+
}
139+
}
140+
141+
public static long qpow(long a, int k) {
142+
long res = 1;
143+
while (k != 0) {
144+
if ((k & 1) == 1) {
145+
res = res * a % MOD;
146+
}
147+
k >>= 1;
148+
a = a * a % MOD;
149+
}
150+
return res;
151+
}
152+
153+
public static long comb(int m, int n) {
154+
return (int) f[m] * g[n] % MOD * g[m - n] % MOD;
155+
}
156+
157+
public int countGoodArrays(int n, int m, int k) {
158+
return (int) (comb(n - 1, k) * m % MOD * qpow(m - 1, n - k - 1) % MOD);
159+
}
160+
}
111161
```
112162

113163
#### C++
114164

115165
```cpp
116-
166+
const int MX = 1e5 + 10;
167+
const int MOD = 1e9 + 7;
168+
long long f[MX];
169+
long long g[MX];
170+
171+
long long qpow(long a, int k) {
172+
long res = 1;
173+
while (k != 0) {
174+
if ((k & 1) == 1) {
175+
res = res * a % MOD;
176+
}
177+
k >>= 1;
178+
a = a * a % MOD;
179+
}
180+
return res;
181+
}
182+
183+
int init = []() {
184+
f[0] = g[0] = 1;
185+
for (int i = 1; i < MX; ++i) {
186+
f[i] = f[i - 1] * i % MOD;
187+
g[i] = qpow(f[i], MOD - 2);
188+
}
189+
return 0;
190+
}();
191+
192+
long long comb(int m, int n) {
193+
return f[m] * g[n] % MOD * g[m - n] % MOD;
194+
}
195+
196+
class Solution {
197+
public:
198+
int countGoodArrays(int n, int m, int k) {
199+
return comb(n - 1, k) * m % MOD * qpow(m - 1, n - k - 1) % MOD;
200+
}
201+
};
117202
```
118203
119204
#### Go
120205
121206
```go
207+
const MX = 1e5 + 10
208+
const MOD = 1e9 + 7
209+
210+
var f [MX]int64
211+
var g [MX]int64
212+
213+
func qpow(a int64, k int) int64 {
214+
res := int64(1)
215+
for k != 0 {
216+
if k&1 == 1 {
217+
res = res * a % MOD
218+
}
219+
a = a * a % MOD
220+
k >>= 1
221+
}
222+
return res
223+
}
224+
225+
func init() {
226+
f[0], g[0] = 1, 1
227+
for i := 1; i < MX; i++ {
228+
f[i] = f[i-1] * int64(i) % MOD
229+
g[i] = qpow(f[i], MOD-2)
230+
}
231+
}
232+
233+
func comb(m, n int) int64 {
234+
return f[m] * g[n] % MOD * g[m-n] % MOD
235+
}
236+
237+
func countGoodArrays(n int, m int, k int) int {
238+
ans := comb(n-1, k) * int64(m) % MOD * qpow(int64(m-1), n-k-1) % MOD
239+
return int(ans)
240+
}
241+
```
122242

243+
#### TypeScript
244+
245+
```ts
246+
const MX = 1e5 + 10;
247+
const MOD = BigInt(1e9 + 7);
248+
249+
const f: bigint[] = Array(MX).fill(1n);
250+
const g: bigint[] = Array(MX).fill(1n);
251+
252+
function qpow(a: bigint, k: number): bigint {
253+
let res = 1n;
254+
while (k !== 0) {
255+
if ((k & 1) === 1) {
256+
res = (res * a) % MOD;
257+
}
258+
a = (a * a) % MOD;
259+
k >>= 1;
260+
}
261+
return res;
262+
}
263+
264+
(function init() {
265+
for (let i = 1; i < MX; ++i) {
266+
f[i] = (f[i - 1] * BigInt(i)) % MOD;
267+
g[i] = qpow(f[i], Number(MOD - 2n));
268+
}
269+
})();
270+
271+
function comb(m: number, n: number): bigint {
272+
return (((f[m] * g[n]) % MOD) * g[m - n]) % MOD;
273+
}
274+
275+
export function countGoodArrays(n: number, m: number, k: number): number {
276+
const ans = (((comb(n - 1, k) * BigInt(m)) % MOD) * qpow(BigInt(m - 1), n - k - 1)) % MOD;
277+
return Number(ans);
278+
}
123279
```
124280

125281
<!-- tabs:end -->

‎solution/3400-3499/3405.Count the Number of Arrays with K Matching Adjacent Elements/README_EN.md

Lines changed: 158 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -97,25 +97,181 @@ tags:
9797
#### Python3
9898

9999
```python
100+
mx = 10**5 + 10
101+
mod = 10**9 + 7
102+
f = [1] + [0] * mx
103+
g = [1] + [0] * mx
100104

105+
for i in range(1, mx):
106+
f[i] = f[i - 1] * i % mod
107+
g[i] = pow(f[i], mod - 2, mod)
108+
109+
110+
def comb(m: int, n: int) -> int:
111+
return f[m] * g[n] * g[m - n] % mod
112+
113+
114+
class Solution:
115+
def countGoodArrays(self, n: int, m: int, k: int) -> int:
116+
return comb(n - 1, k) * m * pow(m - 1, n - k - 1, mod) % mod
101117
```
102118

103119
#### Java
104120

105121
```java
106-
122+
class Solution {
123+
private static final int N = (int) 1e5 + 10;
124+
private static final int MOD = (int) 1e9 + 7;
125+
private static final long[] f = new long[N];
126+
private static final long[] g = new long[N];
127+
128+
static {
129+
f[0] = 1;
130+
g[0] = 1;
131+
for (int i = 1; i < N; ++i) {
132+
f[i] = f[i - 1] * i % MOD;
133+
g[i] = qpow(f[i], MOD - 2);
134+
}
135+
}
136+
137+
public static long qpow(long a, int k) {
138+
long res = 1;
139+
while (k != 0) {
140+
if ((k & 1) == 1) {
141+
res = res * a % MOD;
142+
}
143+
k >>= 1;
144+
a = a * a % MOD;
145+
}
146+
return res;
147+
}
148+
149+
public static long comb(int m, int n) {
150+
return (int) f[m] * g[n] % MOD * g[m - n] % MOD;
151+
}
152+
153+
public int countGoodArrays(int n, int m, int k) {
154+
return (int) (comb(n - 1, k) * m % MOD * qpow(m - 1, n - k - 1) % MOD);
155+
}
156+
}
107157
```
108158

109159
#### C++
110160

111161
```cpp
112-
162+
const int MX = 1e5 + 10;
163+
const int MOD = 1e9 + 7;
164+
long long f[MX];
165+
long long g[MX];
166+
167+
long long qpow(long a, int k) {
168+
long res = 1;
169+
while (k != 0) {
170+
if ((k & 1) == 1) {
171+
res = res * a % MOD;
172+
}
173+
k >>= 1;
174+
a = a * a % MOD;
175+
}
176+
return res;
177+
}
178+
179+
int init = []() {
180+
f[0] = g[0] = 1;
181+
for (int i = 1; i < MX; ++i) {
182+
f[i] = f[i - 1] * i % MOD;
183+
g[i] = qpow(f[i], MOD - 2);
184+
}
185+
return 0;
186+
}();
187+
188+
long long comb(int m, int n) {
189+
return f[m] * g[n] % MOD * g[m - n] % MOD;
190+
}
191+
192+
class Solution {
193+
public:
194+
int countGoodArrays(int n, int m, int k) {
195+
return comb(n - 1, k) * m % MOD * qpow(m - 1, n - k - 1) % MOD;
196+
}
197+
};
113198
```
114199
115200
#### Go
116201
117202
```go
203+
const MX = 1e5 + 10
204+
const MOD = 1e9 + 7
205+
206+
var f [MX]int64
207+
var g [MX]int64
208+
209+
func qpow(a int64, k int) int64 {
210+
res := int64(1)
211+
for k != 0 {
212+
if k&1 == 1 {
213+
res = res * a % MOD
214+
}
215+
a = a * a % MOD
216+
k >>= 1
217+
}
218+
return res
219+
}
220+
221+
func init() {
222+
f[0], g[0] = 1, 1
223+
for i := 1; i < MX; i++ {
224+
f[i] = f[i-1] * int64(i) % MOD
225+
g[i] = qpow(f[i], MOD-2)
226+
}
227+
}
228+
229+
func comb(m, n int) int64 {
230+
return f[m] * g[n] % MOD * g[m-n] % MOD
231+
}
232+
233+
func countGoodArrays(n int, m int, k int) int {
234+
ans := comb(n-1, k) * int64(m) % MOD * qpow(int64(m-1), n-k-1) % MOD
235+
return int(ans)
236+
}
237+
```
118238

239+
#### TypeScript
240+
241+
```ts
242+
const MX = 1e5 + 10;
243+
const MOD = BigInt(1e9 + 7);
244+
245+
const f: bigint[] = Array(MX).fill(1n);
246+
const g: bigint[] = Array(MX).fill(1n);
247+
248+
function qpow(a: bigint, k: number): bigint {
249+
let res = 1n;
250+
while (k !== 0) {
251+
if ((k & 1) === 1) {
252+
res = (res * a) % MOD;
253+
}
254+
a = (a * a) % MOD;
255+
k >>= 1;
256+
}
257+
return res;
258+
}
259+
260+
(function init() {
261+
for (let i = 1; i < MX; ++i) {
262+
f[i] = (f[i - 1] * BigInt(i)) % MOD;
263+
g[i] = qpow(f[i], Number(MOD - 2n));
264+
}
265+
})();
266+
267+
function comb(m: number, n: number): bigint {
268+
return (((f[m] * g[n]) % MOD) * g[m - n]) % MOD;
269+
}
270+
271+
export function countGoodArrays(n: number, m: number, k: number): number {
272+
const ans = (((comb(n - 1, k) * BigInt(m)) % MOD) * qpow(BigInt(m - 1), n - k - 1)) % MOD;
273+
return Number(ans);
274+
}
119275
```
120276

121277
<!-- tabs:end -->

0 commit comments

Comments
 (0)