Skip to content

Commit 97b2aca

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1423 (doocs#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)