Skip to content

Commit 533169c

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1005
No.1005. Maximize Sum of Array After K Negations
1 parent b2e87c7 commit 533169c

File tree

8 files changed

+372
-51
lines changed

8 files changed

+372
-51
lines changed

‎.github/workflows/contributors.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,4 +16,4 @@ jobs:
1616
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
1717
svgPath: images/contributors.svg
1818
svgWidth: 890
19-
commitMessage: "chore: update contributors to leetcode project @doocs"
19+
commitMessage: "chore: auto update contributors"

‎.github/workflows/starcharts.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,5 +14,5 @@ jobs:
1414
with:
1515
github_token: ${{ secrets.GITHUB_TOKEN }}
1616
svg_path: images/starcharts.svg
17-
commit_message: "chore: update starcharts to leetcode project @doocs"
17+
commit_message: "chore: auto update starcharts"
1818
stars_change: "50"

‎solution/1000-1099/1005.Maximize Sum Of Array After K Negations/README.md‎

Lines changed: 127 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,6 @@
4343
<li><code>-100 &lt;= A[i] &lt;= 100</code></li>
4444
</ol>
4545

46-
4746
## 解法
4847

4948
<!-- 这里可写通用的实现逻辑 -->
@@ -55,15 +54,141 @@
5554
<!-- 这里可写当前语言的特殊实现逻辑 -->
5655

5756
```python
58-
57+
class Solution:
58+
def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
59+
counter = Counter(nums)
60+
ans = sum(nums)
61+
for i in range(-100, 0):
62+
if counter[i]:
63+
ops = min(counter[i], k)
64+
ans -= (i * ops * 2)
65+
counter[i] -= ops
66+
counter[-i] += ops
67+
k -= ops
68+
if k == 0:
69+
break
70+
if k > 0 and k % 2 == 1 and not counter[0]:
71+
for i in range(1, 101):
72+
if counter[i]:
73+
ans -= 2 * i
74+
break
75+
return ans
5976
```
6077

6178
### **Java**
6279

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

6582
```java
83+
class Solution {
84+
public int largestSumAfterKNegations(int[] nums, int k) {
85+
int ans = 0;
86+
Map<Integer, Integer> counter = new HashMap<>();
87+
for (int num : nums) {
88+
ans += num;
89+
counter.put(num, counter.getOrDefault(num, 0) + 1);
90+
}
91+
for (int i = -100; i < 0; ++i) {
92+
if (counter.getOrDefault(i, 0) > 0) {
93+
int ops = Math.min(counter.get(i), k);
94+
ans -= (i * ops * 2);
95+
counter.put(i, counter.getOrDefault(i, 0) - ops);
96+
counter.put(-i, counter.getOrDefault(-i, 0) + ops);
97+
k -= ops;
98+
if (k == 0) {
99+
break;
100+
}
101+
}
102+
}
103+
if (k > 0 && (k % 2) == 1 && counter.get(0) == null) {
104+
for (int i = 1; i < 101; ++i) {
105+
if (counter.getOrDefault(i, 0) > 0) {
106+
ans -= 2 * i;
107+
break;
108+
}
109+
}
110+
}
111+
return ans;
112+
}
113+
}
114+
```
66115

116+
### **C++**
117+
118+
```cpp
119+
class Solution {
120+
public:
121+
int largestSumAfterKNegations(vector<int>& nums, int k) {
122+
unordered_map<int, int> counter;
123+
for (int num: nums) ++counter[num];
124+
int ans = accumulate(nums.begin(), nums.end(), 0);
125+
for (int i = -100; i < 0; ++i)
126+
{
127+
if (counter[i])
128+
{
129+
int ops = min(counter[i], k);
130+
ans -= (i * ops * 2);
131+
counter[i] -= ops;
132+
counter[-i] += ops;
133+
k -= ops;
134+
if (k == 0) break;
135+
}
136+
}
137+
if (k > 0 && k % 2 == 1 && !counter[0])
138+
{
139+
for (int i = 1; i < 101; ++i)
140+
{
141+
if (counter[i])
142+
{
143+
ans -= 2 * i;
144+
break;
145+
}
146+
}
147+
}
148+
return ans;
149+
}
150+
};
151+
```
152+
153+
### **Go**
154+
155+
```cpp
156+
func largestSumAfterKNegations(nums []int, k int) int {
157+
ans := 0
158+
counter := make(map[int]int)
159+
for _, num := range nums {
160+
ans += num
161+
counter[num]++
162+
}
163+
for i := -100; i < 0; i++ {
164+
if counter[i] > 0 {
165+
ops := min(counter[i], k)
166+
ans -= (i * ops * 2)
167+
counter[i] -= ops
168+
counter[-i] += ops
169+
k -= ops
170+
if k == 0 {
171+
break
172+
}
173+
}
174+
}
175+
if k > 0 && k%2 == 1 && counter[0] == 0 {
176+
for i := 1; i < 101; i++ {
177+
if counter[i] > 0 {
178+
ans -= 2 * i
179+
break
180+
}
181+
}
182+
}
183+
return ans
184+
}
185+
186+
func min(a, b int) int {
187+
if a < b {
188+
return a
189+
}
190+
return b
191+
}
67192
```
68193

69194
### **...**
@@ -73,4 +198,3 @@
73198
```
74199

75200
<!-- tabs:end -->
76-
<!-- tabs:end -->

‎solution/1000-1099/1005.Maximize Sum Of Array After K Negations/README_EN.md‎

Lines changed: 127 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -6,20 +6,12 @@
66

77
<p>Given an array <code>A</code> of integers, we <strong>must</strong>&nbsp;modify the array in the following way: we choose an <code>i</code>&nbsp;and replace&nbsp;<code>A[i]</code> with <code>-A[i]</code>, and we repeat this process <code>K</code> times in total.&nbsp; (We may choose the same index <code>i</code> multiple times.)</p>
88

9-
10-
119
<p>Return the largest possible sum of the array after modifying it in this way.</p>
1210

13-
14-
1511
<p>&nbsp;</p>
1612

17-
18-
1913
<p><strong>Example 1:</strong></p>
2014

21-
22-
2315
<pre>
2416

2517
<strong>Input: </strong>A = <span id="example-input-1-1">[4,2,3]</span>, K = <span id="example-input-1-2">1</span>
@@ -30,14 +22,10 @@
3022

3123
</pre>
3224

33-
34-
3525
<div>
3626

3727
<p><strong>Example 2:</strong></p>
3828

39-
40-
4129
<pre>
4230

4331
<strong>Input: </strong>A = <span id="example-input-2-1">[3,-1,0,2]</span>, K = <span id="example-input-2-2">3</span>
@@ -48,14 +36,10 @@
4836

4937
</pre>
5038

51-
52-
5339
<div>
5440

5541
<p><strong>Example 3:</strong></p>
5642

57-
58-
5943
<pre>
6044

6145
<strong>Input: </strong>A = <span id="example-input-3-1">[2,-3,-1,5,-4]</span>, K = <span id="example-input-3-2">2</span>
@@ -70,38 +54,156 @@
7054

7155
</div>
7256

73-
74-
7557
<p>&nbsp;</p>
7658

77-
78-
7959
<p><strong>Note:</strong></p>
8060

81-
82-
8361
<ol>
8462
<li><code>1 &lt;= A.length &lt;= 10000</code></li>
8563
<li><code>1 &lt;= K &lt;= 10000</code></li>
8664
<li><code>-100 &lt;= A[i] &lt;= 100</code></li>
8765
</ol>
8866

89-
90-
9167
## Solutions
9268

9369
<!-- tabs:start -->
9470

9571
### **Python3**
9672

9773
```python
98-
74+
class Solution:
75+
def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
76+
counter = Counter(nums)
77+
ans = sum(nums)
78+
for i in range(-100, 0):
79+
if counter[i]:
80+
ops = min(counter[i], k)
81+
ans -= (i * ops * 2)
82+
counter[i] -= ops
83+
counter[-i] += ops
84+
k -= ops
85+
if k == 0:
86+
break
87+
if k > 0 and k % 2 == 1 and not counter[0]:
88+
for i in range(1, 101):
89+
if counter[i]:
90+
ans -= 2 * i
91+
break
92+
return ans
9993
```
10094

10195
### **Java**
10296

10397
```java
98+
class Solution {
99+
public int largestSumAfterKNegations(int[] nums, int k) {
100+
int ans = 0;
101+
Map<Integer, Integer> counter = new HashMap<>();
102+
for (int num : nums) {
103+
ans += num;
104+
counter.put(num, counter.getOrDefault(num, 0) + 1);
105+
}
106+
for (int i = -100; i < 0; ++i) {
107+
if (counter.getOrDefault(i, 0) > 0) {
108+
int ops = Math.min(counter.get(i), k);
109+
ans -= (i * ops * 2);
110+
counter.put(i, counter.getOrDefault(i, 0) - ops);
111+
counter.put(-i, counter.getOrDefault(-i, 0) + ops);
112+
k -= ops;
113+
if (k == 0) {
114+
break;
115+
}
116+
}
117+
}
118+
if (k > 0 && (k % 2) == 1 && counter.get(0) == null) {
119+
for (int i = 1; i < 101; ++i) {
120+
if (counter.getOrDefault(i, 0) > 0) {
121+
ans -= 2 * i;
122+
break;
123+
}
124+
}
125+
}
126+
return ans;
127+
}
128+
}
129+
```
104130

131+
### **C++**
132+
133+
```cpp
134+
class Solution {
135+
public:
136+
int largestSumAfterKNegations(vector<int>& nums, int k) {
137+
unordered_map<int, int> counter;
138+
for (int num: nums) ++counter[num];
139+
int ans = accumulate(nums.begin(), nums.end(), 0);
140+
for (int i = -100; i < 0; ++i)
141+
{
142+
if (counter[i])
143+
{
144+
int ops = min(counter[i], k);
145+
ans -= (i * ops * 2);
146+
counter[i] -= ops;
147+
counter[-i] += ops;
148+
k -= ops;
149+
if (k == 0) break;
150+
}
151+
}
152+
if (k > 0 && k % 2 == 1 && !counter[0])
153+
{
154+
for (int i = 1; i < 101; ++i)
155+
{
156+
if (counter[i])
157+
{
158+
ans -= 2 * i;
159+
break;
160+
}
161+
}
162+
}
163+
return ans;
164+
}
165+
};
166+
```
167+
168+
### **Go**
169+
170+
```cpp
171+
func largestSumAfterKNegations(nums []int, k int) int {
172+
ans := 0
173+
counter := make(map[int]int)
174+
for _, num := range nums {
175+
ans += num
176+
counter[num]++
177+
}
178+
for i := -100; i < 0; i++ {
179+
if counter[i] > 0 {
180+
ops := min(counter[i], k)
181+
ans -= (i * ops * 2)
182+
counter[i] -= ops
183+
counter[-i] += ops
184+
k -= ops
185+
if k == 0 {
186+
break
187+
}
188+
}
189+
}
190+
if k > 0 && k%2 == 1 && counter[0] == 0 {
191+
for i := 1; i < 101; i++ {
192+
if counter[i] > 0 {
193+
ans -= 2 * i
194+
break
195+
}
196+
}
197+
}
198+
return ans
199+
}
200+
201+
func min(a, b int) int {
202+
if a < b {
203+
return a
204+
}
205+
return b
206+
}
105207
```
106208

107209
### **...**
@@ -111,4 +213,3 @@
111213
```
112214

113215
<!-- tabs:end -->
114-
<!-- tabs:end -->

0 commit comments

Comments
 (0)