Skip to content

Commit 5d2197d

Browse files
Nothing-avilNothing-avil
authored
feat: add solutions to lc problem: No.3026 (#2313)
1 parent d44c573 commit 5d2197d

File tree

7 files changed

+361
-6
lines changed

7 files changed

+361
-6
lines changed

‎solution/3000-3099/3026.Maximum Good Subarray Sum/README.md

+121-3
Original file line numberDiff line numberDiff line change
@@ -55,19 +55,137 @@
5555
<!-- tabs:start -->
5656

5757
```python
58-
58+
class Solution:
59+
def maximumSubarraySum(self, nums: List[int], k: int) -> int:
60+
p = {}
61+
r = float('-inf')
62+
p[nums[0]] = 0
63+
s = 0
64+
n = len(nums)
65+
for i in range(n):
66+
s += nums[i]
67+
if nums[i] - k in p:
68+
r = max(r, s - p[nums[i] - k])
69+
if nums[i] + k in p:
70+
r = max(r, s - p[nums[i] + k])
71+
if i + 1 == n:
72+
break
73+
if nums[i + 1] not in p or p[nums[i + 1]] > s:
74+
p[nums[i + 1]] = s
75+
return r if r != float('-inf') else 0
5976
```
6077

6178
```java
62-
79+
class Solution {
80+
public long maximumSubarraySum(int[] nums, int k) {
81+
HashMap<Integer, Long> p = new HashMap<>();
82+
long r = Long.MIN_VALUE;
83+
p.put(nums[0], 0L);
84+
long s = 0;
85+
int n = nums.length;
86+
for (int i = 0;; ++i) {
87+
s += nums[i];
88+
if (p.containsKey(nums[i] - k)) {
89+
r = Math.max(r, s - p.get(nums[i] - k));
90+
}
91+
if (p.containsKey(nums[i] + k)) {
92+
r = Math.max(r, s - p.get(nums[i] + k));
93+
}
94+
if (i + 1 == n) break;
95+
if (!p.containsKey(nums[i + 1]) || p.get(nums[i + 1]) > s) {
96+
p.put(nums[i + 1], s);
97+
}
98+
}
99+
return r == Long.MIN_VALUE ? 0 : r;
100+
}
101+
}
63102
```
64103

65104
```cpp
66-
105+
class Solution {
106+
public:
107+
long long maximumSubarraySum(vector<int>& nums, int k) {
108+
unordered_map<int, long long> p;
109+
long long r = LONG_LONG_MIN;
110+
p[nums[0]] = 0;
111+
long long s = 0;
112+
const int n = nums.size();
113+
for (int i = 0;; ++i) {
114+
s += nums[i];
115+
auto t = p.find(nums[i] - k);
116+
if (t != p.end()) {
117+
r = max(r, s - t->second);
118+
}
119+
t = p.find(nums[i] + k);
120+
if (t != p.end()) {
121+
r = max(r, s - t->second);
122+
}
123+
if (i + 1 == n)
124+
break;
125+
t = p.find(nums[i + 1]);
126+
if (t == p.end() || t->second > s) {
127+
p[nums[i + 1]] = s;
128+
}
129+
}
130+
return r == LONG_LONG_MIN ? 0 : r;
131+
}
132+
};
67133
```
68134
69135
```go
136+
func maximumSubarraySum(nums []int, k int) int64 {
137+
p := make(map[int]int64)
138+
var r int64 = math.MinInt64
139+
p[nums[0]] = 0
140+
var s int64 = 0
141+
n := len(nums)
142+
for i := 0; ; i++ {
143+
s += int64(nums[i])
144+
if t, ok := p[nums[i]-k]; ok {
145+
r = max(r, s-t)
146+
}
147+
if t, ok := p[nums[i]+k]; ok {
148+
r = max(r, s-t)
149+
}
150+
if i+1 == n {
151+
break
152+
}
153+
if t, ok := p[nums[i+1]]; !ok || t > s {
154+
p[nums[i+1]] = s
155+
}
156+
}
157+
if r == math.MinInt64 {
158+
return 0
159+
}
160+
return r
161+
}
162+
```
70163

164+
```ts
165+
function maximumSubarraySum(nums: number[], k: number): number {
166+
const p: Map<number, number> = new Map();
167+
let r: number = Number.MIN_SAFE_INTEGER;
168+
p.set(nums[0], 0);
169+
let s: number = 0;
170+
const n: number = nums.length;
171+
for (let i = 0; ; ++i) {
172+
s += nums[i];
173+
let t: number | undefined = p.get(nums[i] - k);
174+
if (t !== undefined) {
175+
r = Math.max(r, s - t);
176+
}
177+
t = p.get(nums[i] + k);
178+
if (t !== undefined) {
179+
r = Math.max(r, s - t);
180+
}
181+
if (i + 1 === n) break;
182+
t = p.get(nums[i + 1]);
183+
if (t === undefined || t > s) {
184+
p.set(nums[i + 1], s);
185+
}
186+
}
187+
return r === Number.MIN_SAFE_INTEGER ? 0 : r;
188+
}
71189
```
72190

73191
<!-- tabs:end -->

‎solution/3000-3099/3026.Maximum Good Subarray Sum/README_EN.md

+121-3
Original file line numberDiff line numberDiff line change
@@ -51,19 +51,137 @@
5151
<!-- tabs:start -->
5252

5353
```python
54-
54+
class Solution:
55+
def maximumSubarraySum(self, nums: List[int], k: int) -> int:
56+
p = {}
57+
r = float('-inf')
58+
p[nums[0]] = 0
59+
s = 0
60+
n = len(nums)
61+
for i in range(n):
62+
s += nums[i]
63+
if nums[i] - k in p:
64+
r = max(r, s - p[nums[i] - k])
65+
if nums[i] + k in p:
66+
r = max(r, s - p[nums[i] + k])
67+
if i + 1 == n:
68+
break
69+
if nums[i + 1] not in p or p[nums[i + 1]] > s:
70+
p[nums[i + 1]] = s
71+
return r if r != float('-inf') else 0
5572
```
5673

5774
```java
58-
75+
class Solution {
76+
public long maximumSubarraySum(int[] nums, int k) {
77+
HashMap<Integer, Long> p = new HashMap<>();
78+
long r = Long.MIN_VALUE;
79+
p.put(nums[0], 0L);
80+
long s = 0;
81+
int n = nums.length;
82+
for (int i = 0;; ++i) {
83+
s += nums[i];
84+
if (p.containsKey(nums[i] - k)) {
85+
r = Math.max(r, s - p.get(nums[i] - k));
86+
}
87+
if (p.containsKey(nums[i] + k)) {
88+
r = Math.max(r, s - p.get(nums[i] + k));
89+
}
90+
if (i + 1 == n) break;
91+
if (!p.containsKey(nums[i + 1]) || p.get(nums[i + 1]) > s) {
92+
p.put(nums[i + 1], s);
93+
}
94+
}
95+
return r == Long.MIN_VALUE ? 0 : r;
96+
}
97+
}
5998
```
6099

61100
```cpp
62-
101+
class Solution {
102+
public:
103+
long long maximumSubarraySum(vector<int>& nums, int k) {
104+
unordered_map<int, long long> p;
105+
long long r = LONG_LONG_MIN;
106+
p[nums[0]] = 0;
107+
long long s = 0;
108+
const int n = nums.size();
109+
for (int i = 0;; ++i) {
110+
s += nums[i];
111+
auto t = p.find(nums[i] - k);
112+
if (t != p.end()) {
113+
r = max(r, s - t->second);
114+
}
115+
t = p.find(nums[i] + k);
116+
if (t != p.end()) {
117+
r = max(r, s - t->second);
118+
}
119+
if (i + 1 == n)
120+
break;
121+
t = p.find(nums[i + 1]);
122+
if (t == p.end() || t->second > s) {
123+
p[nums[i + 1]] = s;
124+
}
125+
}
126+
return r == LONG_LONG_MIN ? 0 : r;
127+
}
128+
};
63129
```
64130
65131
```go
132+
func maximumSubarraySum(nums []int, k int) int64 {
133+
p := make(map[int]int64)
134+
var r int64 = math.MinInt64
135+
p[nums[0]] = 0
136+
var s int64 = 0
137+
n := len(nums)
138+
for i := 0; ; i++ {
139+
s += int64(nums[i])
140+
if t, ok := p[nums[i]-k]; ok {
141+
r = max(r, s-t)
142+
}
143+
if t, ok := p[nums[i]+k]; ok {
144+
r = max(r, s-t)
145+
}
146+
if i+1 == n {
147+
break
148+
}
149+
if t, ok := p[nums[i+1]]; !ok || t > s {
150+
p[nums[i+1]] = s
151+
}
152+
}
153+
if r == math.MinInt64 {
154+
return 0
155+
}
156+
return r
157+
}
158+
```
66159

160+
```ts
161+
function maximumSubarraySum(nums: number[], k: number): number {
162+
const p: Map<number, number> = new Map();
163+
let r: number = Number.MIN_SAFE_INTEGER;
164+
p.set(nums[0], 0);
165+
let s: number = 0;
166+
const n: number = nums.length;
167+
for (let i = 0; ; ++i) {
168+
s += nums[i];
169+
let t: number | undefined = p.get(nums[i] - k);
170+
if (t !== undefined) {
171+
r = Math.max(r, s - t);
172+
}
173+
t = p.get(nums[i] + k);
174+
if (t !== undefined) {
175+
r = Math.max(r, s - t);
176+
}
177+
if (i + 1 === n) break;
178+
t = p.get(nums[i + 1]);
179+
if (t === undefined || t > s) {
180+
p.set(nums[i + 1], s);
181+
}
182+
}
183+
return r === Number.MIN_SAFE_INTEGER ? 0 : r;
184+
}
67185
```
68186

69187
<!-- tabs:end -->

‎solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.cpp

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public:
3+
long long maximumSubarraySum(vector<int>& nums, int k) {
4+
unordered_map<int, long long> p;
5+
long long r = LONG_LONG_MIN;
6+
p[nums[0]] = 0;
7+
long long s = 0;
8+
const int n = nums.size();
9+
for (int i = 0;; ++i) {
10+
s += nums[i];
11+
auto t = p.find(nums[i] - k);
12+
if (t != p.end()) {
13+
r = max(r, s - t->second);
14+
}
15+
t = p.find(nums[i] + k);
16+
if (t != p.end()) {
17+
r = max(r, s - t->second);
18+
}
19+
if (i + 1 == n)
20+
break;
21+
t = p.find(nums[i + 1]);
22+
if (t == p.end() || t->second > s) {
23+
p[nums[i + 1]] = s;
24+
}
25+
}
26+
return r == LONG_LONG_MIN ? 0 : r;
27+
}
28+
};

‎solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.go

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
func maximumSubarraySum(nums []int, k int) int64 {
2+
p := make(map[int]int64)
3+
var r int64 = math.MinInt64
4+
p[nums[0]] = 0
5+
var s int64 = 0
6+
n := len(nums)
7+
for i := 0; ; i++ {
8+
s += int64(nums[i])
9+
if t, ok := p[nums[i]-k]; ok {
10+
r = max(r, s-t)
11+
}
12+
if t, ok := p[nums[i]+k]; ok {
13+
r = max(r, s-t)
14+
}
15+
if i+1 == n {
16+
break
17+
}
18+
if t, ok := p[nums[i+1]]; !ok || t > s {
19+
p[nums[i+1]] = s
20+
}
21+
}
22+
if r == math.MinInt64 {
23+
return 0
24+
}
25+
return r
26+
}

‎solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.java

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public long maximumSubarraySum(int[] nums, int k) {
3+
HashMap<Integer, Long> p = new HashMap<>();
4+
long r = Long.MIN_VALUE;
5+
p.put(nums[0], 0L);
6+
long s = 0;
7+
int n = nums.length;
8+
for (int i = 0;; ++i) {
9+
s += nums[i];
10+
if (p.containsKey(nums[i] - k)) {
11+
r = Math.max(r, s - p.get(nums[i] - k));
12+
}
13+
if (p.containsKey(nums[i] + k)) {
14+
r = Math.max(r, s - p.get(nums[i] + k));
15+
}
16+
if (i + 1 == n) break;
17+
if (!p.containsKey(nums[i + 1]) || p.get(nums[i + 1]) > s) {
18+
p.put(nums[i + 1], s);
19+
}
20+
}
21+
return r == Long.MIN_VALUE ? 0 : r;
22+
}
23+
}

‎solution/3000-3099/3026.Maximum Good Subarray Sum/Solution.py

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution:
2+
def maximumSubarraySum(self, nums: List[int], k: int) -> int:
3+
p = {}
4+
r = float('-inf')
5+
p[nums[0]] = 0
6+
s = 0
7+
n = len(nums)
8+
for i in range(n):
9+
s += nums[i]
10+
if nums[i] - k in p:
11+
r = max(r, s - p[nums[i] - k])
12+
if nums[i] + k in p:
13+
r = max(r, s - p[nums[i] + k])
14+
if i + 1 == n:
15+
break
16+
if nums[i + 1] not in p or p[nums[i + 1]] > s:
17+
p[nums[i + 1]] = s
18+
return r if r != float('-inf') else 0

0 commit comments

Comments
 (0)