40
40
41
41
时间复杂度 $O(m \times n)$,空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为棋盘的行数和列数。
42
42
43
+ 我们注意到 $f[ i] [ j ] $ 只与 $f[ i-1] [ j ] $ 和 $f[ i] [ j-1 ] $ 有关,因此我们可以仅用两行数组 $f[ 2] [ n+1 ] $ 来存储状态,从而将空间复杂度优化到 $O(n)$。
44
+
43
45
<!-- tabs:start -->
44
46
45
47
### ** Python3**
@@ -55,6 +57,17 @@ class Solution:
55
57
return f[m][n]
56
58
```
57
59
60
+ ``` python
61
+ class Solution :
62
+ def maxValue (self , grid : List[List[int ]]) -> int :
63
+ m, n = len (grid), len (grid[0 ])
64
+ f = [[0 ] * (n + 1 ) for _ in range (2 )]
65
+ for i, row in enumerate (grid, 1 ):
66
+ for j, v in enumerate (row, 1 ):
67
+ f[i & 1 ][j] = max (f[i & 1 ^ 1 ][j], f[i & 1 ][j - 1 ]) + v
68
+ return f[m & 1 ][n]
69
+ ```
70
+
58
71
### ** Java**
59
72
60
73
``` java
@@ -72,6 +85,21 @@ class Solution {
72
85
}
73
86
```
74
87
88
+ ``` java
89
+ class Solution {
90
+ public int maxValue (int [][] grid ) {
91
+ int m = grid. length, n = grid[0 ]. length;
92
+ int [][] f = new int [2 ][n + 1 ];
93
+ for (int i = 1 ; i <= m; ++ i) {
94
+ for (int j = 1 ; j <= n; ++ j) {
95
+ f[i & 1 ][j] = Math . max(f[i & 1 ^ 1 ][j], f[i & 1 ][j - 1 ]) + grid[i - 1 ][j - 1 ];
96
+ }
97
+ }
98
+ return f[m & 1 ][n];
99
+ }
100
+ }
101
+ ```
102
+
75
103
### ** C++**
76
104
77
105
``` cpp
@@ -90,6 +118,22 @@ public:
90
118
};
91
119
```
92
120
121
+ ```cpp
122
+ class Solution {
123
+ public:
124
+ int maxValue(vector<vector<int>>& grid) {
125
+ int m = grid.size(), n = grid[0].size();
126
+ vector<vector<int>> f(2, vector<int>(n + 1, 0));
127
+ for (int i = 1; i <= m; ++i) {
128
+ for (int j = 1; j <= n; ++j) {
129
+ f[i & 1][j] = max(f[i & 1 ^ 1][j], f[i & 1][j - 1]) + grid[i - 1][j - 1];
130
+ }
131
+ }
132
+ return f[m & 1][n];
133
+ }
134
+ };
135
+ ```
136
+
93
137
### ** Go**
94
138
95
139
``` go
@@ -115,6 +159,29 @@ func max(a, b int) int {
115
159
}
116
160
```
117
161
162
+ ``` go
163
+ func maxValue (grid [][]int ) int {
164
+ m , n := len (grid), len (grid[0 ])
165
+ f := make ([][]int , 2 )
166
+ for i := range f {
167
+ f[i] = make ([]int , n+1 )
168
+ }
169
+ for i := 1 ; i <= m; i++ {
170
+ for j := 1 ; j <= n; j++ {
171
+ f[i&1 ][j] = max (f[i&1 ^1 ][j], f[i&1 ][j-1 ]) + grid[i-1 ][j-1 ]
172
+ }
173
+ }
174
+ return f[m&1 ][n]
175
+ }
176
+
177
+ func max (a , b int ) int {
178
+ if a > b {
179
+ return a
180
+ }
181
+ return b
182
+ }
183
+ ```
184
+
118
185
### ** JavaScript**
119
186
120
187
``` js
@@ -125,17 +192,33 @@ func max(a, b int) int {
125
192
var maxValue = function (grid ) {
126
193
const m = grid .length ;
127
194
const n = grid[0 ].length ;
128
- let dp = new Array (m + 1 );
129
- for (let i = 0 ; i < m + 1 ; ++ i) {
130
- dp[i] = new Array (n + 1 ).fill (0 );
195
+ const f = new Array (m + 1 ).fill (0 ).map (() => new Array (n + 1 ).fill (0 ));
196
+ for (let i = 1 ; i <= m; ++ i) {
197
+ for (let j = 1 ; j <= n; ++ j) {
198
+ f[i][j] = Math .max (f[i - 1 ][j], f[i][j - 1 ]) + grid[i - 1 ][j - 1 ];
199
+ }
131
200
}
132
- for (let i = 1 ; i < m + 1 ; ++ i) {
133
- for (let j = 1 ; j < n + 1 ; ++ j) {
134
- dp[i][j] =
135
- Math .max (dp[i - 1 ][j], dp[i][j - 1 ]) + grid[i - 1 ][j - 1 ];
201
+ return f[m][n];
202
+ };
203
+ ```
204
+
205
+ ``` js
206
+ /**
207
+ * @param {number[][]} grid
208
+ * @return {number}
209
+ */
210
+ var maxValue = function (grid ) {
211
+ const m = grid .length ;
212
+ const n = grid[0 ].length ;
213
+ const f = new Array (2 ).fill (0 ).map (() => new Array (n + 1 ).fill (0 ));
214
+ for (let i = 1 ; i <= m; ++ i) {
215
+ for (let j = 1 ; j <= n; ++ j) {
216
+ f[i & 1 ][j] =
217
+ Math .max (f[(i & 1 ) ^ 1 ][j], f[i & 1 ][j - 1 ]) +
218
+ grid[i - 1 ][j - 1 ];
136
219
}
137
220
}
138
- return dp[m ][n];
221
+ return f[m & 1 ][n];
139
222
};
140
223
```
141
224
@@ -155,6 +238,22 @@ function maxValue(grid: number[][]): number {
155
238
}
156
239
```
157
240
241
+ ``` ts
242
+ function maxValue(grid : number [][]): number {
243
+ const m = grid .length ;
244
+ const n = grid [0 ].length ;
245
+ const f = Array .from ({ length: 2 }, _ => new Array (n + 1 ).fill (0 ));
246
+ for (let i = 1 ; i <= m ; ++ i ) {
247
+ for (let j = 1 ; j <= n ; ++ j ) {
248
+ f [i & 1 ][j ] =
249
+ Math .max (f [(i & 1 ) ^ 1 ][j ], f [i & 1 ][j - 1 ]) +
250
+ grid [i - 1 ][j - 1 ];
251
+ }
252
+ }
253
+ return f [m & 1 ][n ];
254
+ }
255
+ ```
256
+
158
257
### ** Rust**
159
258
160
259
``` rust
0 commit comments