Skip to content

Commit 69e4725

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lcci problem: No.16.17
16.17.Contiguous Sequence
1 parent ae50856 commit 69e4725

File tree

7 files changed

+334
-19
lines changed

7 files changed

+334
-19
lines changed

‎lcci/16.17.Contiguous Sequence/README.md

+140-8
Original file line numberDiff line numberDiff line change
@@ -20,28 +20,140 @@
2020

2121
## 解法
2222

23-
动态规划
24-
2523
<!-- 这里可写通用的实现逻辑 -->
2624

25+
**方法一：动态规划**
26+
27+
定义状态 `dp[i]` 表示以 `nums[i]` 结尾的连续子数组的最大和，初始时 `dp[0] = nums[0]`，当 $i\gt 0$ 时，状态转移方程为：
28+
29+
$$
30+
dp[i]=\max(dp[i-1],0)+nums[i], i>0
31+
$$
32+
33+
答案为 `dp` 数组中的最大值。
34+
35+
时间复杂度 $O(n)$，其中 $n$ 表示 `nums` 的长度。
36+
37+
由于 `dp[i]` 只与 `dp[i-1]` 有关，因此可以使用滚动数组优化空间复杂度，将空间复杂度降低到 $O(1)$。
38+
2739
<!-- tabs:start -->
2840

2941
### **Python3**
3042

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

3345
```python
46+
class Solution:
47+
def maxSubArray(self, nums: List[int]) -> int:
48+
n = len(nums)
49+
dp = [0] * n
50+
dp[0] = nums[0]
51+
for i in range(1, n):
52+
dp[i] = max(dp[i - 1], 0) + nums[i]
53+
return max(dp)
54+
```
3455

35-
56+
```python
57+
class Solution:
58+
def maxSubArray(self, nums: List[int]) -> int:
59+
ans = s = -inf
60+
for v in nums:
61+
s = max(s, 0) + v
62+
ans = max(ans, s)
63+
return ans
3664
```
3765

3866
### **Java**
3967

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

4270
```java
71+
class Solution {
72+
public int maxSubArray(int[] nums) {
73+
int inf = Integer.MIN_VALUE;
74+
int ans = inf, s = inf;
75+
for (int v : nums) {
76+
s = Math.max(s, 0) + v;
77+
ans = Math.max(ans, s);
78+
}
79+
return ans;
80+
}
81+
}
82+
```
4383

84+
### **C++**
85+
86+
```cpp
87+
class Solution {
88+
public:
89+
int maxSubArray(vector<int>& nums) {
90+
int n = nums.size();
91+
vector<int> dp(n);
92+
dp[0] = nums[0];
93+
int ans = dp[0];
94+
for (int i = 1; i < n; ++i) {
95+
dp[i] = max(dp[i - 1], 0) + nums[i];
96+
ans = max(ans, dp[i]);
97+
}
98+
return ans;
99+
}
100+
};
101+
```
44102
103+
```cpp
104+
class Solution {
105+
public:
106+
int maxSubArray(vector<int>& nums) {
107+
int s = INT_MIN, ans = INT_MIN;
108+
for (int v : nums) {
109+
s = max(s, 0) + v;
110+
ans = max(ans, s);
111+
}
112+
return ans;
113+
}
114+
};
115+
```
116+
117+
### **Go**
118+
119+
```go
120+
func maxSubArray(nums []int) int {
121+
n := len(nums)
122+
dp := make([]int, n)
123+
dp[0] = nums[0]
124+
ans := dp[0]
125+
for i := 1; i < n; i++ {
126+
dp[i] = max(dp[i-1], 0) + nums[i]
127+
ans = max(ans, dp[i])
128+
}
129+
return ans
130+
}
131+
132+
func max(a, b int) int {
133+
if a > b {
134+
return a
135+
}
136+
return b
137+
}
138+
```
139+
140+
```go
141+
func maxSubArray(nums []int) int {
142+
inf := math.MinInt32
143+
ans, s := inf, inf
144+
for _, v := range nums {
145+
s = max(s, 0) + v
146+
ans = max(ans, s)
147+
}
148+
return ans
149+
}
150+
151+
func max(a, b int) int {
152+
if a > b {
153+
return a
154+
}
155+
return b
156+
}
45157
```
46158

47159
### **JavaScript**
@@ -52,12 +164,32 @@
52164
* @return {number}
53165
*/
54166
var maxSubArray = function (nums) {
55-
let dp = [-Infinity];
56-
for (let i = 0; i < nums.length; i++) {
57-
let cur = nums[i];
58-
dp[i + 1] = Math.max(dp[i] + cur, cur);
167+
const n = nums.length;
168+
const dp = new Array(n).fill(0);
169+
dp[0] = nums[0];
170+
let ans = dp[0];
171+
for (let i = 1; i < n; ++i) {
172+
dp[i] = Math.max(dp[i - 1], 0) + nums[i];
173+
ans = Math.max(ans, dp[i]);
174+
}
175+
return ans;
176+
};
177+
```
178+
179+
```js
180+
/**
181+
* @param {number[]} nums
182+
* @return {number}
183+
*/
184+
var maxSubArray = function (nums) {
185+
const inf = -Infinity;
186+
let s = inf;
187+
let ans = inf;
188+
for (const v of nums) {
189+
s = Math.max(s, 0) + v;
190+
ans = Math.max(ans, s);
59191
}
60-
return Math.max(...dp);
192+
return ans;
61193
};
62194
```
63195

‎lcci/16.17.Contiguous Sequence/README_EN.md

+142-6
Original file line numberDiff line numberDiff line change
@@ -37,15 +37,131 @@
3737
### **Python3**
3838

3939
```python
40+
class Solution:
41+
def maxSubArray(self, nums: List[int]) -> int:
42+
n = len(nums)
43+
dp = [0] * n
44+
dp[0] = nums[0]
45+
for i in range(1, n):
46+
dp[i] = max(dp[i - 1], 0) + nums[i]
47+
return max(dp)
48+
```
4049

41-
50+
```python
51+
class Solution:
52+
def maxSubArray(self, nums: List[int]) -> int:
53+
ans = s = -inf
54+
for v in nums:
55+
s = max(s, 0) + v
56+
ans = max(ans, s)
57+
return ans
4258
```
4359

4460
### **Java**
4561

4662
```java
63+
class Solution {
64+
public int maxSubArray(int[] nums) {
65+
int n = nums.length;
66+
int[] dp = new int[n];
67+
dp[0] = nums[0];
68+
int ans = dp[0];
69+
for (int i = 1; i < n; ++i) {
70+
dp[i] = Math.max(dp[i - 1], 0) + nums[i];
71+
ans = Math.max(ans, dp[i]);
72+
}
73+
return ans;
74+
}
75+
}
76+
```
77+
78+
```java
79+
class Solution {
80+
public int maxSubArray(int[] nums) {
81+
int inf = Integer.MIN_VALUE;
82+
int ans = inf, s = inf;
83+
for (int v : nums) {
84+
s = Math.max(s, 0) + v;
85+
ans = Math.max(ans, s);
86+
}
87+
return ans;
88+
}
89+
}
90+
```
91+
92+
### **C++**
93+
94+
```cpp
95+
class Solution {
96+
public:
97+
int maxSubArray(vector<int>& nums) {
98+
int n = nums.size();
99+
vector<int> dp(n);
100+
dp[0] = nums[0];
101+
int ans = dp[0];
102+
for (int i = 1; i < n; ++i) {
103+
dp[i] = max(dp[i - 1], 0) + nums[i];
104+
ans = max(ans, dp[i]);
105+
}
106+
return ans;
107+
}
108+
};
109+
```
110+
111+
```cpp
112+
class Solution {
113+
public:
114+
int maxSubArray(vector<int>& nums) {
115+
int s = INT_MIN, ans = INT_MIN;
116+
for (int v : nums) {
117+
s = max(s, 0) + v;
118+
ans = max(ans, s);
119+
}
120+
return ans;
121+
}
122+
};
123+
```
47124

125+
### **Go**
126+
127+
```go
128+
func maxSubArray(nums []int) int {
129+
n := len(nums)
130+
dp := make([]int, n)
131+
dp[0] = nums[0]
132+
ans := dp[0]
133+
for i := 1; i < n; i++ {
134+
dp[i] = max(dp[i-1], 0) + nums[i]
135+
ans = max(ans, dp[i])
136+
}
137+
return ans
138+
}
139+
140+
func max(a, b int) int {
141+
if a > b {
142+
return a
143+
}
144+
return b
145+
}
146+
```
48147

148+
```go
149+
func maxSubArray(nums []int) int {
150+
inf := math.MinInt32
151+
ans, s := inf, inf
152+
for _, v := range nums {
153+
s = max(s, 0) + v
154+
ans = max(ans, s)
155+
}
156+
return ans
157+
}
158+
159+
func max(a, b int) int {
160+
if a > b {
161+
return a
162+
}
163+
return b
164+
}
49165
```
50166

51167
### **JavaScript**
@@ -56,12 +172,32 @@
56172
* @return {number}
57173
*/
58174
var maxSubArray = function (nums) {
59-
let dp = [-Infinity];
60-
for (let i = 0; i < nums.length; i++) {
61-
let cur = nums[i];
62-
dp[i + 1] = Math.max(dp[i] + cur, cur);
175+
const n = nums.length;
176+
const dp = new Array(n).fill(0);
177+
dp[0] = nums[0];
178+
let ans = dp[0];
179+
for (let i = 1; i < n; ++i) {
180+
dp[i] = Math.max(dp[i - 1], 0) + nums[i];
181+
ans = Math.max(ans, dp[i]);
182+
}
183+
return ans;
184+
};
185+
```
186+
187+
```js
188+
/**
189+
* @param {number[]} nums
190+
* @return {number}
191+
*/
192+
var maxSubArray = function (nums) {
193+
const inf = -Infinity;
194+
let s = inf;
195+
let ans = inf;
196+
for (const v of nums) {
197+
s = Math.max(s, 0) + v;
198+
ans = Math.max(ans, s);
63199
}
64-
return Math.max(...dp);
200+
return ans;
65201
};
66202
```
67203

‎lcci/16.17.Contiguous Sequence/Solution.cpp

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution {
2+
public:
3+
int maxSubArray(vector<int>& nums) {
4+
int s = INT_MIN, ans = INT_MIN;
5+
for (int v : nums) {
6+
s = max(s, 0) + v;
7+
ans = max(ans, s);
8+
}
9+
return ans;
10+
}
11+
};

‎lcci/16.17.Contiguous Sequence/Solution.go

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
func maxSubArray(nums []int) int {
2+
inf := math.MinInt32
3+
ans, s := inf, inf
4+
for _, v := range nums {
5+
s = max(s, 0) + v
6+
ans = max(ans, s)
7+
}
8+
return ans
9+
}
10+
11+
func max(a, b int) int {
12+
if a > b {
13+
return a
14+
}
15+
return b
16+
}

‎lcci/16.17.Contiguous Sequence/Solution.java

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution {
2+
public int maxSubArray(int[] nums) {
3+
int inf = Integer.MIN_VALUE;
4+
int ans = inf, s = inf;
5+
for (int v : nums) {
6+
s = Math.max(s, 0) + v;
7+
ans = Math.max(ans, s);
8+
}
9+
return ans;
10+
}
11+
}

0 commit comments

Comments
 (0)