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 97b2aca

Browse files
feat: add solutions to lc problem: No.1423 (#2054)
No.1423.Maximum Points You Can Obtain from Cards
1 parent 27c748f commit 97b2aca

File tree

16 files changed

+547
-175
lines changed

16 files changed

+547
-175
lines changed

‎solution/1400-1499/1423.Maximum Points You Can Obtain from Cards/README.md‎

Lines changed: 194 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,15 @@
6464

6565
<!-- 这里可写通用的实现逻辑 -->
6666

67-
要让左右两侧共 `k` 个元素和最大,可以转换为求中间连续数组 `n - k` 个元素和最小值 `mi`,然后用数组总和 `s` 减去 `mi` 得到答案。
67+
**方法一:滑动窗口**
68+
69+
我们可以用一个长度为 $k$ 的滑动窗口来模拟这个过程。
70+
71+
初始时我们将窗口放在数组的末尾,即索引为 $n-k$ 到索引 $n-1$ 的这 $k$ 个位置,窗口内卡牌的点数之和记为 $s,ドル初始答案 $ans$ 的值也为 $s$。这其实是从数组的开头拿走 0ドル$ 张卡牌的情况。
72+
73+
接下来,我们考虑从数组的开头依次拿 1,ドル 2, ..., k$ 张卡牌的情况,假设取到的卡牌为 $cardPoints[i],ドル那么我们将其加入 $s,ドル由于窗口的长度限制为 $k,ドル我们需要将 $cardPoints[n-k+i]$ 从 $s$ 中减去,这样我们就可以计算出拿到的 $k$ 张卡牌的点数之和,更新答案 $ans$。
74+
75+
时间复杂度 $O(k),ドル其中 $k$ 给题目中给出的整数。空间复杂度 $O(1)$。
6876

6977
<!-- tabs:start -->
7078

@@ -75,16 +83,11 @@
7583
```python
7684
class Solution:
7785
def maxScore(self, cardPoints: List[int], k: int) -> int:
78-
n = len(cardPoints)
79-
s = [0] * (n + 1)
80-
for i in range(n):
81-
s[i + 1] = s[i] + cardPoints[i]
82-
mi = inf
83-
for i in range(n):
84-
j = i + (n - k) - 1
85-
if j < n:
86-
mi = min(mi, s[j + 1] - s[i])
87-
return s[-1] - mi
86+
ans = s = sum(cardPoints[-k:])
87+
for i, x in enumerate(cardPoints[:k]):
88+
s += x - cardPoints[-k + i]
89+
ans = max(ans, s)
90+
return ans
8891
```
8992

9093
### **Java**
@@ -93,21 +96,17 @@ class Solution:
9396

9497
```java
9598
class Solution {
96-
9799
public int maxScore(int[] cardPoints, int k) {
98-
int n = cardPoints.length;
99-
int[] s = new int[n + 1];
100-
for (int i = 0; i < n; ++i) {
101-
s[i + 1] = s[i] + cardPoints[i];
100+
int s = 0, n = cardPoints.length;
101+
for (int i = n - k; i < n; ++i) {
102+
s += cardPoints[i];
102103
}
103-
int mi = Integer.MAX_VALUE;
104-
for (int i = 0; i < n; ++i) {
105-
int j = i + (n - k) - 1;
106-
if (j < n) {
107-
mi = Math.min(mi, s[j + 1] - s[i]);
108-
}
104+
int ans = s;
105+
for (int i = 0; i < k; ++i) {
106+
s += cardPoints[i] - cardPoints[n - k + i];
107+
ans = Math.max(ans, s);
109108
}
110-
return s[n] - mi;
109+
return ans;
111110
}
112111
}
113112
```
@@ -119,14 +118,13 @@ class Solution {
119118
public:
120119
int maxScore(vector<int>& cardPoints, int k) {
121120
int n = cardPoints.size();
122-
vector<int> s(n + 1);
123-
for (int i = 0; i < n; ++i) s[i + 1] = s[i] + cardPoints[i];
124-
int mi = INT_MAX;
125-
for (int i = 0; i < n; ++i) {
126-
int j = i + (n - k) - 1;
127-
if (j < n) mi = min(mi, s[j + 1] - s[i]);
121+
int s = accumulate(cardPoints.end() - k, cardPoints.end(), 0);
122+
int ans = s;
123+
for (int i = 0; i < k; ++i) {
124+
s += cardPoints[i] - cardPoints[n - k + i];
125+
ans = max(ans, s);
128126
}
129-
return s[n] - mi;
127+
return ans;
130128
}
131129
};
132130
```
@@ -136,18 +134,16 @@ public:
136134
```go
137135
func maxScore(cardPoints []int, k int) int {
138136
n := len(cardPoints)
139-
s := make([]int, n+1)
140-
for i := 0; i < n; i++ {
141-
s[i+1] = s[i] + cardPoints[i]
137+
s := 0
138+
for _, x := range cardPoints[n-k:] {
139+
s += x
142140
}
143-
mi := math.MaxInt64
144-
for i := 0; i < n; i++ {
145-
j := i + (n - k) - 1
146-
if j < n {
147-
mi = min(mi, s[j+1]-s[i])
148-
}
141+
ans := s
142+
for i := 0; i < k; i++ {
143+
s += cardPoints[i] - cardPoints[n-k+i]
144+
ans = max(ans, s)
149145
}
150-
return s[n] - mi
146+
return ans
151147
}
152148
```
153149

@@ -156,13 +152,13 @@ func maxScore(cardPoints []int, k int) int {
156152
```ts
157153
function maxScore(cardPoints: number[], k: number): number {
158154
const n = cardPoints.length;
159-
let sum = cardPoints.slice(0, n-k).reduce((r, v) => r + v, 0);
160-
let min = sum;
161-
for (let i = 0; i < k; i++) {
162-
sum += cardPoints[n - k + i] -cardPoints[i];
163-
min = Math.min(min, sum);
155+
let s = cardPoints.slice(-k).reduce((a, b) => a + b);
156+
let ans = s;
157+
for (let i = 0; i < k; ++i) {
158+
s += cardPoints[i] -cardPoints[n - k + i];
159+
ans = Math.max(ans, s);
164160
}
165-
return cardPoints.reduce((r, v) =>r+v, 0) -min;
161+
return ans;
166162
}
167163
```
168164

@@ -171,17 +167,160 @@ function maxScore(cardPoints: number[], k: number): number {
171167
```rust
172168
impl Solution {
173169
pub fn max_score(card_points: Vec<i32>, k: i32) -> i32 {
174-
let (k, n) = (k as usize, card_points.len());
175-
let mut sum = card_points
176-
.iter()
177-
.take(n - k)
178-
.sum::<i32>();
179-
let mut min = sum;
170+
let n = card_points.len();
171+
let k = k as usize;
172+
let mut s: i32 = card_points[n - k..].iter().sum();
173+
let mut ans: i32 = s;
180174
for i in 0..k {
181-
sum += card_points[n - k + i] - card_points[i];
182-
min = min.min(sum);
175+
s += card_points[i] - card_points[n - k + i];
176+
ans = ans.max(s);
177+
}
178+
ans
179+
}
180+
}
181+
```
182+
183+
### **C#**
184+
185+
```cs
186+
public class Solution {
187+
public int MaxScore(int[] cardPoints, int k) {
188+
int n = cardPoints.Length;
189+
int s = cardPoints[^k..].Sum();
190+
int ans = s;
191+
for (int i = 0; i < k; ++i) {
192+
s += cardPoints[i] - cardPoints[n - k + i];
193+
ans = Math.Max(ans, s);
194+
}
195+
return ans;
196+
}
197+
}
198+
```
199+
200+
### **PHP**
201+
202+
```php
203+
class Solution {
204+
/**
205+
* @param Integer[] $cardPoints
206+
* @param Integer $k
207+
* @return Integer
208+
*/
209+
function maxScore($cardPoints, $k) {
210+
$n = count($cardPoints);
211+
$s = array_sum(array_slice($cardPoints, -$k));
212+
$ans = $s;
213+
for ($i = 0; $i < $k; ++$i) {
214+
$s += $cardPoints[$i] - $cardPoints[$n - $k + $i];
215+
$ans = max($ans, $s);
216+
}
217+
return $ans;
218+
}
219+
}
220+
```
221+
222+
### **Kotlin**
223+
224+
```kotlin
225+
class Solution {
226+
fun maxScore(cardPoints: IntArray, k: Int): Int {
227+
val n = cardPoints.size
228+
var s = cardPoints.sliceArray(n - k until n).sum()
229+
var ans = s
230+
for (i in 0 until k) {
231+
s += cardPoints[i] - cardPoints[n - k + i]
232+
ans = maxOf(ans, s)
233+
}
234+
return ans
235+
}
236+
}
237+
```
238+
239+
### **Swift**
240+
241+
```swift
242+
class Solution {
243+
func maxScore(_ cardPoints: [Int], _ k: Int) -> Int {
244+
let n = cardPoints.count
245+
var s = cardPoints.suffix(k).reduce(0, +)
246+
var ans = s
247+
for i in 0..<k {
248+
s += cardPoints[i] - cardPoints[n - k + i]
249+
ans = max(ans, s)
250+
}
251+
return ans
252+
}
253+
}
254+
```
255+
256+
### **JavaScript**
257+
258+
```js
259+
/**
260+
* @param {number[]} cardPoints
261+
* @param {number} k
262+
* @return {number}
263+
*/
264+
var maxScore = function (cardPoints, k) {
265+
const n = cardPoints.length;
266+
let s = cardPoints.slice(-k).reduce((a, b) => a + b);
267+
let ans = s;
268+
for (let i = 0; i < k; ++i) {
269+
s += cardPoints[i] - cardPoints[n - k + i];
270+
ans = Math.max(ans, s);
271+
}
272+
return ans;
273+
};
274+
```
275+
276+
### **Dart**
277+
278+
```dart
279+
class Solution {
280+
int maxScore(List<int> cardPoints, int k) {
281+
int n = cardPoints.length;
282+
int s = cardPoints.sublist(n - k).reduce((a, b) => a + b);
283+
int ans = s;
284+
for (int i = 0; i < k; ++i) {
285+
s += cardPoints[i] - cardPoints[n - k + i];
286+
ans = s > ans ? s : ans;
287+
}
288+
return ans;
289+
}
290+
}
291+
```
292+
293+
### **Ruby**
294+
295+
```rb
296+
# @param {Integer[]} card_points
297+
# @param {Integer} k
298+
# @return {Integer}
299+
def max_score(card_points, k)
300+
n = card_points.length
301+
s = card_points[-k..].sum
302+
ans = s
303+
k.times do |i|
304+
s += card_points[i] - card_points[n - k + i]
305+
ans = [ans, s].max
306+
end
307+
ans
308+
end
309+
```
310+
311+
### **Scala**
312+
313+
```scala
314+
object Solution {
315+
def maxScore(cardPoints: Array[Int], k: Int): Int = {
316+
val n = cardPoints.length
317+
var s = cardPoints.takeRight(k).sum
318+
var ans = s
319+
for (i <- 0 until k) {
320+
s += cardPoints(i) - cardPoints(n - k + i)
321+
ans = ans.max(s)
183322
}
184-
card_points.iter().sum::<i32>() -min
323+
ans
185324
}
186325
}
187326
```

0 commit comments

Comments
(0)

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