Skip to content

Commit deaf2ae

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1937 (#1635)
No.1937.Maximum Number of Points with Cost
1 parent a043f1b commit deaf2ae

File tree

7 files changed

+384
-2
lines changed

7 files changed

+384
-2
lines changed

‎solution/1900-1999/1937.Maximum Number of Points with Cost/README.md

Lines changed: 146 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,22 +63,167 @@
6363

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

66+
**方法一：动态规划**
67+
68+
我们定义 $f[i][j]$ 表示选取前 $i-1$ 行，并且第 $i-1$ 行选择第 $j$ 列的格子时的最大得分。初始时 $f[0][j] = points[0][j]$。
69+
70+
对于 $i > 0$ 的情况，对于 $f[i][j]$，我们考虑是从上一行的哪一列转移过来的，记上一行选择的列为 $k$，那么有：
71+
72+
$$
73+
f[i][j]=
74+
\begin{cases}
75+
\max(f[i - 1][k] + k - j + points[i][j]), & 0 \le k < j \\
76+
\max(f[i - 1][k] - k + j + points[i][j]), & j < k < n
77+
\end{cases}
78+
$$
79+
80+
其中 $n$ 表示列数。答案为 $\max\limits_{0 \le j < n} f[m - 1][j]$。
81+
82+
我们注意到 $f[i]$ 的值只跟 $f[i-1]$ 的值有关，因此我们可以使用滚动数组优化空间复杂度。
83+
84+
时间复杂度 $O(m \times n)$，空间复杂度 $O(n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
85+
6686
<!-- tabs:start -->
6787

6888
### **Python3**
6989

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

7292
```python
73-
93+
class Solution:
94+
def maxPoints(self, points: List[List[int]]) -> int:
95+
n = len(points[0])
96+
f = points[0][:]
97+
for p in points[1:]:
98+
g = [0] * n
99+
lmx = -inf
100+
for j in range(n):
101+
lmx = max(lmx, f[j] + j)
102+
g[j] = max(g[j], p[j] + lmx - j)
103+
rmx = -inf
104+
for j in range(n - 1, -1, -1):
105+
rmx = max(rmx, f[j] - j)
106+
g[j] = max(g[j], p[j] + rmx + j)
107+
f = g
108+
return max(f)
74109
```
75110

76111
### **Java**
77112

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

80115
```java
116+
class Solution {
117+
public long maxPoints(int[][] points) {
118+
int n = points[0].length;
119+
long[] f = new long[n];
120+
final long inf = 1L << 60;
121+
for (int[] p : points) {
122+
long[] g = new long[n];
123+
long lmx = -inf, rmx = -inf;
124+
for (int j = 0; j < n; ++j) {
125+
lmx = Math.max(lmx, f[j] + j);
126+
g[j] = Math.max(g[j], p[j] + lmx - j);
127+
}
128+
for (int j = n - 1; j >= 0; --j) {
129+
rmx = Math.max(rmx, f[j] - j);
130+
g[j] = Math.max(g[j], p[j] + rmx + j);
131+
}
132+
f = g;
133+
}
134+
long ans = 0;
135+
for (long x : f) {
136+
ans = Math.max(ans, x);
137+
}
138+
return ans;
139+
}
140+
}
141+
```
142+
143+
### **C++**
144+
145+
```cpp
146+
class Solution {
147+
public:
148+
long long maxPoints(vector<vector<int>>& points) {
149+
using ll = long long;
150+
int n = points[0].size();
151+
vector<ll> f(n);
152+
const ll inf = 1e18;
153+
for (auto& p : points) {
154+
vector<ll> g(n);
155+
ll lmx = -inf, rmx = -inf;
156+
for (int j = 0; j < n; ++j) {
157+
lmx = max(lmx, f[j] + j);
158+
g[j] = max(g[j], p[j] + lmx - j);
159+
}
160+
for (int j = n - 1; ~j; --j) {
161+
rmx = max(rmx, f[j] - j);
162+
g[j] = max(g[j], p[j] + rmx + j);
163+
}
164+
f = move(g);
165+
}
166+
return *max_element(f.begin(), f.end());
167+
}
168+
};
169+
```
170+
171+
### **Go**
172+
173+
```go
174+
func maxPoints(points [][]int) (ans int64) {
175+
n := len(points[0])
176+
const inf int64 = 1e18
177+
f := make([]int64, n)
178+
for _, p := range points {
179+
g := make([]int64, n)
180+
lmx, rmx := -inf, -inf
181+
for j := range p {
182+
lmx = max(lmx, f[j]+int64(j))
183+
g[j] = max(g[j], int64(p[j])+lmx-int64(j))
184+
}
185+
for j := n - 1; j >= 0; j-- {
186+
rmx = max(rmx, f[j]-int64(j))
187+
g[j] = max(g[j], int64(p[j])+rmx+int64(j))
188+
}
189+
f = g
190+
}
191+
for _, x := range f {
192+
ans = max(ans, x)
193+
}
194+
return
195+
}
196+
197+
func max(a, b int64) int64 {
198+
if a > b {
199+
return a
200+
}
201+
return b
202+
}
203+
```
81204

205+
### **TypeScript**
206+
207+
```ts
208+
function maxPoints(points: number[][]): number {
209+
const n = points[0].length;
210+
const f: number[] = new Array(n).fill(0);
211+
for (const p of points) {
212+
const g: number[] = new Array(n).fill(0);
213+
let lmx = -Infinity;
214+
let rmx = -Infinity;
215+
for (let j = 0; j < n; ++j) {
216+
lmx = Math.max(lmx, f[j] + j);
217+
g[j] = Math.max(g[j], p[j] + lmx - j);
218+
}
219+
for (let j = n - 1; ~j; --j) {
220+
rmx = Math.max(rmx, f[j] - j);
221+
g[j] = Math.max(g[j], p[j] + rmx + j);
222+
}
223+
f.splice(0, n, ...g);
224+
}
225+
return Math.max(...f);
226+
}
82227
```
83228

84229
### **...**

‎solution/1900-1999/1937.Maximum Number of Points with Cost/README_EN.md

Lines changed: 126 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -62,13 +62,138 @@ Your final score is 12 - 1 = 11.
6262
### **Python3**
6363

6464
```python
65-
65+
class Solution:
66+
def maxPoints(self, points: List[List[int]]) -> int:
67+
n = len(points[0])
68+
f = points[0][:]
69+
for p in points[1:]:
70+
g = [0] * n
71+
lmx = -inf
72+
for j in range(n):
73+
lmx = max(lmx, f[j] + j)
74+
g[j] = max(g[j], p[j] + lmx - j)
75+
rmx = -inf
76+
for j in range(n - 1, -1, -1):
77+
rmx = max(rmx, f[j] - j)
78+
g[j] = max(g[j], p[j] + rmx + j)
79+
f = g
80+
return max(f)
6681
```
6782

6883
### **Java**
6984

7085
```java
86+
class Solution {
87+
public long maxPoints(int[][] points) {
88+
int n = points[0].length;
89+
long[] f = new long[n];
90+
final long inf = 1L << 60;
91+
for (int[] p : points) {
92+
long[] g = new long[n];
93+
long lmx = -inf, rmx = -inf;
94+
for (int j = 0; j < n; ++j) {
95+
lmx = Math.max(lmx, f[j] + j);
96+
g[j] = Math.max(g[j], p[j] + lmx - j);
97+
}
98+
for (int j = n - 1; j >= 0; --j) {
99+
rmx = Math.max(rmx, f[j] - j);
100+
g[j] = Math.max(g[j], p[j] + rmx + j);
101+
}
102+
f = g;
103+
}
104+
long ans = 0;
105+
for (long x : f) {
106+
ans = Math.max(ans, x);
107+
}
108+
return ans;
109+
}
110+
}
111+
```
112+
113+
### **C++**
114+
115+
```cpp
116+
class Solution {
117+
public:
118+
long long maxPoints(vector<vector<int>>& points) {
119+
using ll = long long;
120+
int n = points[0].size();
121+
vector<ll> f(n);
122+
const ll inf = 1e18;
123+
for (auto& p : points) {
124+
vector<ll> g(n);
125+
ll lmx = -inf, rmx = -inf;
126+
for (int j = 0; j < n; ++j) {
127+
lmx = max(lmx, f[j] + j);
128+
g[j] = max(g[j], p[j] + lmx - j);
129+
}
130+
for (int j = n - 1; ~j; --j) {
131+
rmx = max(rmx, f[j] - j);
132+
g[j] = max(g[j], p[j] + rmx + j);
133+
}
134+
f = move(g);
135+
}
136+
return *max_element(f.begin(), f.end());
137+
}
138+
};
139+
```
140+
141+
### **Go**
142+
143+
```go
144+
func maxPoints(points [][]int) (ans int64) {
145+
n := len(points[0])
146+
const inf int64 = 1e18
147+
f := make([]int64, n)
148+
for _, p := range points {
149+
g := make([]int64, n)
150+
lmx, rmx := -inf, -inf
151+
for j := range p {
152+
lmx = max(lmx, f[j]+int64(j))
153+
g[j] = max(g[j], int64(p[j])+lmx-int64(j))
154+
}
155+
for j := n - 1; j >= 0; j-- {
156+
rmx = max(rmx, f[j]-int64(j))
157+
g[j] = max(g[j], int64(p[j])+rmx+int64(j))
158+
}
159+
f = g
160+
}
161+
for _, x := range f {
162+
ans = max(ans, x)
163+
}
164+
return
165+
}
166+
167+
func max(a, b int64) int64 {
168+
if a > b {
169+
return a
170+
}
171+
return b
172+
}
173+
```
71174

175+
### **TypeScript**
176+
177+
```ts
178+
function maxPoints(points: number[][]): number {
179+
const n = points[0].length;
180+
const f: number[] = new Array(n).fill(0);
181+
for (const p of points) {
182+
const g: number[] = new Array(n).fill(0);
183+
let lmx = -Infinity;
184+
let rmx = -Infinity;
185+
for (let j = 0; j < n; ++j) {
186+
lmx = Math.max(lmx, f[j] + j);
187+
g[j] = Math.max(g[j], p[j] + lmx - j);
188+
}
189+
for (let j = n - 1; ~j; --j) {
190+
rmx = Math.max(rmx, f[j] - j);
191+
g[j] = Math.max(g[j], p[j] + rmx + j);
192+
}
193+
f.splice(0, n, ...g);
194+
}
195+
return Math.max(...f);
196+
}
72197
```
73198

74199
### **...**

‎solution/1900-1999/1937.Maximum Number of Points with Cost/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+
long long maxPoints(vector<vector<int>>& points) {
4+
using ll = long long;
5+
int n = points[0].size();
6+
vector<ll> f(n);
7+
const ll inf = 1e18;
8+
for (auto& p : points) {
9+
vector<ll> g(n);
10+
ll lmx = -inf, rmx = -inf;
11+
for (int j = 0; j < n; ++j) {
12+
lmx = max(lmx, f[j] + j);
13+
g[j] = max(g[j], p[j] + lmx - j);
14+
}
15+
for (int j = n - 1; ~j; --j) {
16+
rmx = max(rmx, f[j] - j);
17+
g[j] = max(g[j], p[j] + rmx + j);
18+
}
19+
f = move(g);
20+
}
21+
return *max_element(f.begin(), f.end());
22+
}
23+
};

‎solution/1900-1999/1937.Maximum Number of Points with Cost/Solution.go

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func maxPoints(points [][]int) (ans int64) {
2+
n := len(points[0])
3+
const inf int64 = 1e18
4+
f := make([]int64, n)
5+
for _, p := range points {
6+
g := make([]int64, n)
7+
lmx, rmx := -inf, -inf
8+
for j := range p {
9+
lmx = max(lmx, f[j]+int64(j))
10+
g[j] = max(g[j], int64(p[j])+lmx-int64(j))
11+
}
12+
for j := n - 1; j >= 0; j-- {
13+
rmx = max(rmx, f[j]-int64(j))
14+
g[j] = max(g[j], int64(p[j])+rmx+int64(j))
15+
}
16+
f = g
17+
}
18+
for _, x := range f {
19+
ans = max(ans, x)
20+
}
21+
return
22+
}
23+
24+
func max(a, b int64) int64 {
25+
if a > b {
26+
return a
27+
}
28+
return b
29+
}

‎solution/1900-1999/1937.Maximum Number of Points with Cost/Solution.java

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public long maxPoints(int[][] points) {
3+
int n = points[0].length;
4+
long[] f = new long[n];
5+
final long inf = 1L << 60;
6+
for (int[] p : points) {
7+
long[] g = new long[n];
8+
long lmx = -inf, rmx = -inf;
9+
for (int j = 0; j < n; ++j) {
10+
lmx = Math.max(lmx, f[j] + j);
11+
g[j] = Math.max(g[j], p[j] + lmx - j);
12+
}
13+
for (int j = n - 1; j >= 0; --j) {
14+
rmx = Math.max(rmx, f[j] - j);
15+
g[j] = Math.max(g[j], p[j] + rmx + j);
16+
}
17+
f = g;
18+
}
19+
long ans = 0;
20+
for (long x : f) {
21+
ans = Math.max(ans, x);
22+
}
23+
return ans;
24+
}
25+
}

0 commit comments

Comments
 (0)