Skip to content

Commit 2846184

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.1787,1788 (doocs#1912)
* No.1787.Make the XOR of All Segments Equal to Zero * No.1788.Maximize the Beauty of the Garden
1 parent 1f2eb6c commit 2846184

File tree

10 files changed

+255
-108
lines changed

10 files changed

+255
-108
lines changed

‎solution/1700-1799/1787.Make the XOR of All Segments Equal to Zero/README.md

+8-8
Original file line numberDiff line numberDiff line change
@@ -111,16 +111,16 @@ class Solution {
111111
public int minChanges(int[] nums, int k) {
112112
int n = 1 << 10;
113113
Map<Integer, Integer>[] cnt = new Map[k];
114+
Arrays.setAll(cnt, i -> new HashMap<>());
114115
int[] size = new int[k];
115-
for (int i = 0; i < k; ++i) {
116-
cnt[i] = new HashMap<>();
117-
}
118116
for (int i = 0; i < nums.length; ++i) {
119-
cnt[i % k].put(nums[i], cnt[i % k].getOrDefault(nums[i], 0) + 1);
120-
size[i % k]++;
117+
int j = i % k;
118+
cnt[j].merge(nums[i], 1, Integer::sum);
119+
size[j]++;
121120
}
122121
int[] f = new int[n];
123-
Arrays.fill(f, 0x3f3f3f3f);
122+
final int inf = 1 << 30;
123+
Arrays.fill(f, inf);
124124
f[0] = 0;
125125
for (int i = 0; i < k; ++i) {
126126
int[] g = new int[n];
@@ -153,13 +153,13 @@ class Solution {
153153
public:
154154
int minChanges(vector<int>& nums, int k) {
155155
int n = 1 << 10;
156-
vector<unordered_map<int, int>> cnt(k);
156+
unordered_map<int, int> cnt[k];
157157
vector<int> size(k);
158158
for (int i = 0; i < nums.size(); ++i) {
159159
cnt[i % k][nums[i]]++;
160160
size[i % k]++;
161161
}
162-
vector<int> f(n, 0x3f3f3f3f);
162+
vector<int> f(n, 1 << 30);
163163
f[0] = 0;
164164
for (int i = 0; i < k; ++i) {
165165
int mi = *min_element(f.begin(), f.end());

‎solution/1700-1799/1787.Make the XOR of All Segments Equal to Zero/README_EN.md

+8-8
Original file line numberDiff line numberDiff line change
@@ -73,16 +73,16 @@ class Solution {
7373
public int minChanges(int[] nums, int k) {
7474
int n = 1 << 10;
7575
Map<Integer, Integer>[] cnt = new Map[k];
76+
Arrays.setAll(cnt, i -> new HashMap<>());
7677
int[] size = new int[k];
77-
for (int i = 0; i < k; ++i) {
78-
cnt[i] = new HashMap<>();
79-
}
8078
for (int i = 0; i < nums.length; ++i) {
81-
cnt[i % k].put(nums[i], cnt[i % k].getOrDefault(nums[i], 0) + 1);
82-
size[i % k]++;
79+
int j = i % k;
80+
cnt[j].merge(nums[i], 1, Integer::sum);
81+
size[j]++;
8382
}
8483
int[] f = new int[n];
85-
Arrays.fill(f, 0x3f3f3f3f);
84+
final int inf = 1 << 30;
85+
Arrays.fill(f, inf);
8686
f[0] = 0;
8787
for (int i = 0; i < k; ++i) {
8888
int[] g = new int[n];
@@ -115,13 +115,13 @@ class Solution {
115115
public:
116116
int minChanges(vector<int>& nums, int k) {
117117
int n = 1 << 10;
118-
vector<unordered_map<int, int>> cnt(k);
118+
unordered_map<int, int> cnt[k];
119119
vector<int> size(k);
120120
for (int i = 0; i < nums.size(); ++i) {
121121
cnt[i % k][nums[i]]++;
122122
size[i % k]++;
123123
}
124-
vector<int> f(n, 0x3f3f3f3f);
124+
vector<int> f(n, 1 << 30);
125125
f[0] = 0;
126126
for (int i = 0; i < k; ++i) {
127127
int mi = *min_element(f.begin(), f.end());

‎solution/1700-1799/1787.Make the XOR of All Segments Equal to Zero/Solution.cpp

+24-24
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,25 @@
1-
class Solution {
2-
public:
3-
int minChanges(vector<int>& nums, int k) {
4-
int n = 1 << 10;
5-
vector<unordered_map<int, int>> cnt(k);
6-
vector<int> size(k);
7-
for (int i = 0; i < nums.size(); ++i) {
8-
cnt[i % k][nums[i]]++;
9-
size[i % k]++;
10-
}
11-
vector<int> f(n, 0x3f3f3f3f);
12-
f[0] = 0;
13-
for (int i = 0; i < k; ++i) {
14-
int mi = *min_element(f.begin(), f.end());
15-
vector<int> g(n, mi + size[i]);
16-
for (int j = 0; j < n; ++j) {
17-
for (auto& [v, c] : cnt[i]) {
18-
g[j] = min(g[j], f[j ^ v] + size[i] - c);
19-
}
20-
}
21-
f = move(g);
22-
}
23-
return f[0];
24-
}
1+
class Solution {
2+
public:
3+
int minChanges(vector<int>& nums, int k) {
4+
int n = 1 << 10;
5+
unordered_map<int, int> cnt[k];
6+
vector<int> size(k);
7+
for (int i = 0; i < nums.size(); ++i) {
8+
cnt[i % k][nums[i]]++;
9+
size[i % k]++;
10+
}
11+
vector<int> f(n, 1 << 30);
12+
f[0] = 0;
13+
for (int i = 0; i < k; ++i) {
14+
int mi = *min_element(f.begin(), f.end());
15+
vector<int> g(n, mi + size[i]);
16+
for (int j = 0; j < n; ++j) {
17+
for (auto& [v, c] : cnt[i]) {
18+
g[j] = min(g[j], f[j ^ v] + size[i] - c);
19+
}
20+
}
21+
f = move(g);
22+
}
23+
return f[0];
24+
}
2525
};

‎solution/1700-1799/1787.Make the XOR of All Segments Equal to Zero/Solution.java

+36-36
Original file line numberDiff line numberDiff line change
@@ -1,37 +1,37 @@
1-
class Solution {
2-
public int minChanges(int[] nums, int k) {
3-
int n = 1 << 10;
4-
Map<Integer, Integer>[] cnt = new Map[k];
5-
int[] size = new int[k];
6-
for (int i = 0; i < k; ++i) {
7-
cnt[i] = new HashMap<>();
8-
}
9-
for (int i = 0; i < nums.length; ++i) {
10-
cnt[i % k].put(nums[i], cnt[i % k].getOrDefault(nums[i], 0) + 1);
11-
size[i % k]++;
12-
}
13-
int[] f = new int[n];
14-
Arrays.fill(f, 0x3f3f3f3f);
15-
f[0] = 0;
16-
for (int i = 0; i < k; ++i) {
17-
int[] g = new int[n];
18-
Arrays.fill(g, min(f) + size[i]);
19-
for (int j = 0; j < n; ++j) {
20-
for (var e : cnt[i].entrySet()) {
21-
int v = e.getKey(), c = e.getValue();
22-
g[j] = Math.min(g[j], f[j ^ v] + size[i] - c);
23-
}
24-
}
25-
f = g;
26-
}
27-
return f[0];
28-
}
29-
30-
private int min(int[] arr) {
31-
int mi = arr[0];
32-
for (int v : arr) {
33-
mi = Math.min(mi, v);
34-
}
35-
return mi;
36-
}
1+
class Solution {
2+
public int minChanges(int[] nums, int k) {
3+
int n = 1 << 10;
4+
Map<Integer, Integer>[] cnt = new Map[k];
5+
Arrays.setAll(cnt, i -> new HashMap<>());
6+
int[] size = new int[k];
7+
for (int i = 0; i < nums.length; ++i) {
8+
int j = i % k;
9+
cnt[j].merge(nums[i], 1, Integer::sum);
10+
size[j]++;
11+
}
12+
int[] f = new int[n];
13+
final int inf = 1 << 30;
14+
Arrays.fill(f, inf);
15+
f[0] = 0;
16+
for (int i = 0; i < k; ++i) {
17+
int[] g = new int[n];
18+
Arrays.fill(g, min(f) + size[i]);
19+
for (int j = 0; j < n; ++j) {
20+
for (var e : cnt[i].entrySet()) {
21+
int v = e.getKey(), c = e.getValue();
22+
g[j] = Math.min(g[j], f[j ^ v] + size[i] - c);
23+
}
24+
}
25+
f = g;
26+
}
27+
return f[0];
28+
}
29+
30+
private int min(int[] arr) {
31+
int mi = arr[0];
32+
for (int v : arr) {
33+
mi = Math.min(mi, v);
34+
}
35+
return mi;
36+
}
3737
}

‎solution/1700-1799/1788.Maximize the Beauty of the Garden/README.md

+57-2
Original file line numberDiff line numberDiff line change
@@ -55,6 +55,14 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
**方法一：哈希表 + 前缀和**
59+
60+
我们用哈希表 $d$ 记录每个美观度第一次出现的位置，用前缀和数组 $s$ 记录当前位置之前的美观度之和。如果一个美观度 $v$ 在位置 $i$ 和 $j$ 出现过（其中 $i \lt j$），那么我们可以得到一个有效的花园 $[i+1,j]$，其美观度为 $s[i] - s[j + 1] + v \times 2$，我们用这个值更新答案。否则，我们将当前美观度所在的位置 $i$ 记录到哈希表 $d$ 中。接下来，我们更新前缀和，如果美观度 $v$ 为负数，我们将其视为 $0$。
61+
62+
遍历完所有的美观度之后，我们就可以得到答案。
63+
64+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为花朵的数量。
65+
5866
<!-- tabs:start -->
5967

6068
### **Python3**
@@ -83,10 +91,11 @@ class Solution:
8391
```java
8492
class Solution {
8593
public int maximumBeauty(int[] flowers) {
86-
int[] s = new int[flowers.length + 1];
94+
int n = flowers.length;
95+
int[] s = new int[n + 1];
8796
Map<Integer, Integer> d = new HashMap<>();
8897
int ans = Integer.MIN_VALUE;
89-
for (int i = 0; i < flowers.length; ++i) {
98+
for (int i = 0; i < n; ++i) {
9099
int v = flowers[i];
91100
if (d.containsKey(v)) {
92101
ans = Math.max(ans, s[i] - s[d.get(v) + 1] + v * 2);
@@ -144,6 +153,52 @@ func maximumBeauty(flowers []int) int {
144153
}
145154
```
146155

156+
### **Rust**
157+
158+
```rust
159+
use std::collections::HashMap;
160+
161+
impl Solution {
162+
pub fn maximum_beauty(flowers: Vec<i32>) -> i32 {
163+
let mut s = vec![0; flowers.len() + 1];
164+
let mut d = HashMap::new();
165+
let mut ans = i32::MIN;
166+
167+
for (i, &v) in flowers.iter().enumerate() {
168+
if let Some(&j) = d.get(&v) {
169+
ans = ans.max(s[i] - s[j + 1] + v * 2);
170+
} else {
171+
d.insert(v, i);
172+
}
173+
s[i + 1] = s[i] + v.max(0);
174+
}
175+
176+
ans
177+
}
178+
}
179+
```
180+
181+
### **TypeScript**
182+
183+
```ts
184+
function maximumBeauty(flowers: number[]): number {
185+
const n = flowers.length;
186+
const s: number[] = Array(n + 1).fill(0);
187+
const d: Map<number, number> = new Map();
188+
let ans = -Infinity;
189+
for (let i = 0; i < n; ++i) {
190+
const v = flowers[i];
191+
if (d.has(v)) {
192+
ans = Math.max(ans, s[i] - s[d.get(v)! + 1] + v * 2);
193+
} else {
194+
d.set(v, i);
195+
}
196+
s[i + 1] = s[i] + Math.max(v, 0);
197+
}
198+
return ans;
199+
}
200+
```
201+
147202
### **...**
148203

149204
```

‎solution/1700-1799/1788.Maximize the Beauty of the Garden/README_EN.md

+57-2
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,14 @@
5252

5353
## Solutions
5454

55+
**Solution 1: Hash Table + Prefix Sum**
56+
57+
We use a hash table $d$ to record the first occurrence of each aesthetic value, and a prefix sum array $s$ to record the sum of the aesthetic values before the current position. If an aesthetic value $v$ appears at positions $i$ and $j$ (where $i \lt j$), then we can get a valid garden $[i+1,j]$, whose aesthetic value is $s[i] - s[j + 1] + v \times 2$. We use this value to update the answer. Otherwise, we record the current position $i$ of the aesthetic value in the hash table $d$. Next, we update the prefix sum. If the aesthetic value $v$ is negative, we treat it as $0$.
58+
59+
After traversing all the aesthetic values, we can get the answer.
60+
61+
The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of flowers.
62+
5563
<!-- tabs:start -->
5664

5765
### **Python3**
@@ -76,10 +84,11 @@ class Solution:
7684
```java
7785
class Solution {
7886
public int maximumBeauty(int[] flowers) {
79-
int[] s = new int[flowers.length + 1];
87+
int n = flowers.length;
88+
int[] s = new int[n + 1];
8089
Map<Integer, Integer> d = new HashMap<>();
8190
int ans = Integer.MIN_VALUE;
82-
for (int i = 0; i < flowers.length; ++i) {
91+
for (int i = 0; i < n; ++i) {
8392
int v = flowers[i];
8493
if (d.containsKey(v)) {
8594
ans = Math.max(ans, s[i] - s[d.get(v) + 1] + v * 2);
@@ -137,6 +146,52 @@ func maximumBeauty(flowers []int) int {
137146
}
138147
```
139148

149+
### **Rust**
150+
151+
```rust
152+
use std::collections::HashMap;
153+
154+
impl Solution {
155+
pub fn maximum_beauty(flowers: Vec<i32>) -> i32 {
156+
let mut s = vec![0; flowers.len() + 1];
157+
let mut d = HashMap::new();
158+
let mut ans = i32::MIN;
159+
160+
for (i, &v) in flowers.iter().enumerate() {
161+
if let Some(&j) = d.get(&v) {
162+
ans = ans.max(s[i] - s[j + 1] + v * 2);
163+
} else {
164+
d.insert(v, i);
165+
}
166+
s[i + 1] = s[i] + v.max(0);
167+
}
168+
169+
ans
170+
}
171+
}
172+
```
173+
174+
### **TypeScript**
175+
176+
```ts
177+
function maximumBeauty(flowers: number[]): number {
178+
const n = flowers.length;
179+
const s: number[] = Array(n + 1).fill(0);
180+
const d: Map<number, number> = new Map();
181+
let ans = -Infinity;
182+
for (let i = 0; i < n; ++i) {
183+
const v = flowers[i];
184+
if (d.has(v)) {
185+
ans = Math.max(ans, s[i] - s[d.get(v)! + 1] + v * 2);
186+
} else {
187+
d.set(v, i);
188+
}
189+
s[i + 1] = s[i] + Math.max(v, 0);
190+
}
191+
return ans;
192+
}
193+
```
194+
140195
### **...**
141196

142197
```

0 commit comments

Comments
 (0)