Skip to content

Commit 54858fa

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1420
No.1420.Build Array Where You Can Find The Maximum Exactly K Comparisons
1 parent cfaac27 commit 54858fa

File tree

7 files changed

+358
-4
lines changed

7 files changed

+358
-4
lines changed

‎solution/1400-1499/1420.Build Array Where You Can Find The Maximum Exactly K Comparisons/README.md

Lines changed: 141 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -70,22 +70,162 @@
7070

7171
<!-- 这里可写通用的实现逻辑 -->
7272

73+
**方法一：动态规划**
74+
75+
假设 $dp[i][c][j]$ 表示长度为 $i$，搜索代价为 $c$，且最大值为 $j$ 的方案数。考虑第 $i$ 个数：
76+
77+
若第 $i$ 个数没有改变搜索代价，说明它不严格大于前 $i-1$ 个数，也就是说，$dp[i][c][j]$ 是从 $dp[i-1][c][j]$ 转移而来，即数组的前 $i-1$ 个数的最大值已经是 $j$，并且第 $i$ 个数没有改变最大值，因此第 $i$ 个数的可选范围是 $[1,..j]$，共有 $j$ 种可选方案。即
78+
79+
$$
80+
dp[i][c][j]=dp[i-1][c][j] \times j
81+
$$
82+
83+
若第 $i$ 个数改变了搜索代价，说明数组前 $i-1$ 个数的最大值小于 $j$，并且第 $i$ 个数恰好为 $j$。此时 $dp[i][c][j]$ 是从所有 $dp[i-1][c-1][j']$ 转移而来，其中 $j'<j$。即
84+
85+
$$
86+
dp[i][c][j] = \sum_{j'=1}^{j-1} f[i-1][c-1][j']
87+
$$
88+
89+
综上，可得
90+
91+
$$
92+
dp[i][c][j] = dp[i-1][c][j] \times j + \sum_{j'=1}^{j-1} f[i-1][c-1][j']
93+
$$
94+
95+
答案为
96+
97+
$$
98+
\sum_{j=1}^{m}dp[n][k][j]
99+
$$
100+
101+
时间复杂度 $O(nkm^2)$。
102+
73103
<!-- tabs:start -->
74104

75105
### **Python3**
76106

77107
<!-- 这里可写当前语言的特殊实现逻辑 -->
78108

79109
```python
80-
110+
class Solution:
111+
def numOfArrays(self, n: int, m: int, k: int) -> int:
112+
if k == 0:
113+
return 0
114+
dp = [[[0] * (m + 1) for _ in range(k + 1)] for _ in range(n + 1)]
115+
mod = 10**9 + 7
116+
for i in range(1, m + 1):
117+
dp[1][1][i] = 1
118+
for i in range(2, n + 1):
119+
for c in range(1, min(k + 1, i + 1)):
120+
for j in range(1, m + 1):
121+
dp[i][c][j] = dp[i - 1][c][j] * j
122+
for j0 in range(1, j):
123+
dp[i][c][j] += dp[i - 1][c - 1][j0]
124+
dp[i][c][j] %= mod
125+
ans = 0
126+
for i in range(1, m + 1):
127+
ans += dp[n][k][i]
128+
ans %= mod
129+
return ans
81130
```
82131

83132
### **Java**
84133

85134
<!-- 这里可写当前语言的特殊实现逻辑 -->
86135

87136
```java
137+
class Solution {
138+
private static final int MOD = (int) 1e9 + 7;
139+
140+
public int numOfArrays(int n, int m, int k) {
141+
if (k == 0) {
142+
return 0;
143+
}
144+
long[][][] dp = new long[n + 1][k + 1][m + 1];
145+
for (int i = 1; i <= m; ++i) {
146+
dp[1][1][i] = 1;
147+
}
148+
for (int i = 2; i <= n; ++i) {
149+
for (int c = 1; c <= Math.min(i, k); ++c) {
150+
for (int j = 1; j <= m; ++j) {
151+
dp[i][c][j] = (dp[i - 1][c][j] * j) % MOD;
152+
for (int j0 = 1; j0 < j; ++j0) {
153+
dp[i][c][j] = (dp[i][c][j] + dp[i - 1][c - 1][j0]) % MOD;
154+
}
155+
}
156+
}
157+
}
158+
long ans = 0;
159+
for (int i = 1; i <= m; ++i) {
160+
ans = (ans + dp[n][k][i]) % MOD;
161+
}
162+
return (int) ans;
163+
}
164+
}
165+
```
166+
167+
### **C++**
168+
169+
```cpp
170+
class Solution {
171+
public:
172+
int numOfArrays(int n, int m, int k) {
173+
if (k == 0) return 0;
174+
int mod = 1e9 + 7;
175+
using ll = long long;
176+
vector<vector<vector<ll>>> dp(n + 1, vector<vector<ll>>(k + 1, vector<ll>(m + 1)));
177+
for (int i = 1; i <= m; ++i) dp[1][1][i] = 1;
178+
for (int i = 2; i <= n; ++i) {
179+
for (int c = 1; c <= min(i, k); ++c) {
180+
for (int j = 1; j <= m; ++j) {
181+
dp[i][c][j] = (dp[i - 1][c][j] * j) % mod;
182+
for (int j0 = 1; j0 < j; ++j0) {
183+
dp[i][c][j] = (dp[i][c][j] + dp[i - 1][c - 1][j0]) % mod;
184+
}
185+
}
186+
}
187+
}
188+
ll ans = 0;
189+
for (int i = 1; i <= m; ++i) ans = (ans + dp[n][k][i]) % mod;
190+
return (int) ans;
191+
}
192+
};
193+
```
88194
195+
### **Go**
196+
197+
```go
198+
func numOfArrays(n int, m int, k int) int {
199+
if k == 0 {
200+
return 0
201+
}
202+
mod := int(1e9) + 7
203+
dp := make([][][]int, n+1)
204+
for i := range dp {
205+
dp[i] = make([][]int, k+1)
206+
for j := range dp[i] {
207+
dp[i][j] = make([]int, m+1)
208+
}
209+
}
210+
for i := 1; i <= m; i++ {
211+
dp[1][1][i] = 1
212+
}
213+
for i := 2; i <= n; i++ {
214+
for c := 1; c <= k && c <= i; c++ {
215+
for j := 1; j <= m; j++ {
216+
dp[i][c][j] = (dp[i-1][c][j] * j) % mod
217+
for j0 := 1; j0 < j; j0++ {
218+
dp[i][c][j] = (dp[i][c][j] + dp[i-1][c-1][j0]) % mod
219+
}
220+
}
221+
}
222+
}
223+
ans := 0
224+
for i := 1; i <= m; i++ {
225+
ans = (ans + dp[n][k][i]) % mod
226+
}
227+
return ans
228+
}
89229
```
90230

91231
### **...**

‎solution/1400-1499/1420.Build Array Where You Can Find The Maximum Exactly K Comparisons/README_EN.md

Lines changed: 113 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,18 +52,130 @@
5252

5353
## Solutions
5454

55+
Dynamic Programming.
56+
5557
<!-- tabs:start -->
5658

5759
### **Python3**
5860

5961
```python
60-
62+
class Solution:
63+
def numOfArrays(self, n: int, m: int, k: int) -> int:
64+
if k == 0:
65+
return 0
66+
dp = [[[0] * (m + 1) for _ in range(k + 1)] for _ in range(n + 1)]
67+
mod = 10**9 + 7
68+
for i in range(1, m + 1):
69+
dp[1][1][i] = 1
70+
for i in range(2, n + 1):
71+
for c in range(1, min(k + 1, i + 1)):
72+
for j in range(1, m + 1):
73+
dp[i][c][j] = dp[i - 1][c][j] * j
74+
for j0 in range(1, j):
75+
dp[i][c][j] += dp[i - 1][c - 1][j0]
76+
dp[i][c][j] %= mod
77+
ans = 0
78+
for i in range(1, m + 1):
79+
ans += dp[n][k][i]
80+
ans %= mod
81+
return ans
6182
```
6283

6384
### **Java**
6485

6586
```java
87+
class Solution {
88+
private static final int MOD = (int) 1e9 + 7;
89+
90+
public int numOfArrays(int n, int m, int k) {
91+
if (k == 0) {
92+
return 0;
93+
}
94+
long[][][] dp = new long[n + 1][k + 1][m + 1];
95+
for (int i = 1; i <= m; ++i) {
96+
dp[1][1][i] = 1;
97+
}
98+
for (int i = 2; i <= n; ++i) {
99+
for (int c = 1; c <= Math.min(i, k); ++c) {
100+
for (int j = 1; j <= m; ++j) {
101+
dp[i][c][j] = (dp[i - 1][c][j] * j) % MOD;
102+
for (int j0 = 1; j0 < j; ++j0) {
103+
dp[i][c][j] = (dp[i][c][j] + dp[i - 1][c - 1][j0]) % MOD;
104+
}
105+
}
106+
}
107+
}
108+
long ans = 0;
109+
for (int i = 1; i <= m; ++i) {
110+
ans = (ans + dp[n][k][i]) % MOD;
111+
}
112+
return (int) ans;
113+
}
114+
}
115+
```
116+
117+
### **C++**
118+
119+
```cpp
120+
class Solution {
121+
public:
122+
int numOfArrays(int n, int m, int k) {
123+
if (k == 0) return 0;
124+
int mod = 1e9 + 7;
125+
using ll = long long;
126+
vector<vector<vector<ll>>> dp(n + 1, vector<vector<ll>>(k + 1, vector<ll>(m + 1)));
127+
for (int i = 1; i <= m; ++i) dp[1][1][i] = 1;
128+
for (int i = 2; i <= n; ++i) {
129+
for (int c = 1; c <= min(i, k); ++c) {
130+
for (int j = 1; j <= m; ++j) {
131+
dp[i][c][j] = (dp[i - 1][c][j] * j) % mod;
132+
for (int j0 = 1; j0 < j; ++j0) {
133+
dp[i][c][j] = (dp[i][c][j] + dp[i - 1][c - 1][j0]) % mod;
134+
}
135+
}
136+
}
137+
}
138+
ll ans = 0;
139+
for (int i = 1; i <= m; ++i) ans = (ans + dp[n][k][i]) % mod;
140+
return (int) ans;
141+
}
142+
};
143+
```
66144
145+
### **Go**
146+
147+
```go
148+
func numOfArrays(n int, m int, k int) int {
149+
if k == 0 {
150+
return 0
151+
}
152+
mod := int(1e9) + 7
153+
dp := make([][][]int, n+1)
154+
for i := range dp {
155+
dp[i] = make([][]int, k+1)
156+
for j := range dp[i] {
157+
dp[i][j] = make([]int, m+1)
158+
}
159+
}
160+
for i := 1; i <= m; i++ {
161+
dp[1][1][i] = 1
162+
}
163+
for i := 2; i <= n; i++ {
164+
for c := 1; c <= k && c <= i; c++ {
165+
for j := 1; j <= m; j++ {
166+
dp[i][c][j] = (dp[i-1][c][j] * j) % mod
167+
for j0 := 1; j0 < j; j0++ {
168+
dp[i][c][j] = (dp[i][c][j] + dp[i-1][c-1][j0]) % mod
169+
}
170+
}
171+
}
172+
}
173+
ans := 0
174+
for i := 1; i <= m; i++ {
175+
ans = (ans + dp[n][k][i]) % mod
176+
}
177+
return ans
178+
}
67179
```
68180

69181
### **...**

‎solution/1400-1499/1420.Build Array Where You Can Find The Maximum Exactly K Comparisons/Solution.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public:
3+
int numOfArrays(int n, int m, int k) {
4+
if (k == 0) return 0;
5+
int mod = 1e9 + 7;
6+
using ll = long long;
7+
vector<vector<vector<ll>>> dp(n + 1, vector<vector<ll>>(k + 1, vector<ll>(m + 1)));
8+
for (int i = 1; i <= m; ++i) dp[1][1][i] = 1;
9+
for (int i = 2; i <= n; ++i) {
10+
for (int c = 1; c <= min(i, k); ++c) {
11+
for (int j = 1; j <= m; ++j) {
12+
dp[i][c][j] = (dp[i - 1][c][j] * j) % mod;
13+
for (int j0 = 1; j0 < j; ++j0) {
14+
dp[i][c][j] = (dp[i][c][j] + dp[i - 1][c - 1][j0]) % mod;
15+
}
16+
}
17+
}
18+
}
19+
ll ans = 0;
20+
for (int i = 1; i <= m; ++i) ans = (ans + dp[n][k][i]) % mod;
21+
return (int) ans;
22+
}
23+
};

‎solution/1400-1499/1420.Build Array Where You Can Find The Maximum Exactly K Comparisons/Solution.go

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
func numOfArrays(n int, m int, k int) int {
2+
if k == 0 {
3+
return 0
4+
}
5+
mod := int(1e9) + 7
6+
dp := make([][][]int, n+1)
7+
for i := range dp {
8+
dp[i] = make([][]int, k+1)
9+
for j := range dp[i] {
10+
dp[i][j] = make([]int, m+1)
11+
}
12+
}
13+
for i := 1; i <= m; i++ {
14+
dp[1][1][i] = 1
15+
}
16+
for i := 2; i <= n; i++ {
17+
for c := 1; c <= k && c <= i; c++ {
18+
for j := 1; j <= m; j++ {
19+
dp[i][c][j] = (dp[i-1][c][j] * j) % mod
20+
for j0 := 1; j0 < j; j0++ {
21+
dp[i][c][j] = (dp[i][c][j] + dp[i-1][c-1][j0]) % mod
22+
}
23+
}
24+
}
25+
}
26+
ans := 0
27+
for i := 1; i <= m; i++ {
28+
ans = (ans + dp[n][k][i]) % mod
29+
}
30+
return ans
31+
}

‎solution/1400-1499/1420.Build Array Where You Can Find The Maximum Exactly K Comparisons/Solution.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
private static final int MOD = (int) 1e9 + 7;
3+
4+
public int numOfArrays(int n, int m, int k) {
5+
if (k == 0) {
6+
return 0;
7+
}
8+
long[][][] dp = new long[n + 1][k + 1][m + 1];
9+
for (int i = 1; i <= m; ++i) {
10+
dp[1][1][i] = 1;
11+
}
12+
for (int i = 2; i <= n; ++i) {
13+
for (int c = 1; c <= Math.min(i, k); ++c) {
14+
for (int j = 1; j <= m; ++j) {
15+
dp[i][c][j] = (dp[i - 1][c][j] * j) % MOD;
16+
for (int j0 = 1; j0 < j; ++j0) {
17+
dp[i][c][j] = (dp[i][c][j] + dp[i - 1][c - 1][j0]) % MOD;
18+
}
19+
}
20+
}
21+
}
22+
long ans = 0;
23+
for (int i = 1; i <= m; ++i) {
24+
ans = (ans + dp[n][k][i]) % MOD;
25+
}
26+
return (int) ans;
27+
}
28+
}

0 commit comments

Comments
 (0)