Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 58a5c21

Browse files
feat: add solutions to lc problem: No.3405 (doocs#4464)
No.3405.Count the Number of Arrays with K Matching Adjacent Elements
1 parent 2e938eb commit 58a5c21

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)

AltStyle によって変換されたページ (->オリジナル) /