Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 2846184

Browse files
feat: add solutions to lc problems: No.1787,1788 (#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‎

Lines changed: 8 additions & 8 deletions
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‎

Lines changed: 8 additions & 8 deletions
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());
Lines changed: 24 additions & 24 deletions
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
};
Lines changed: 36 additions & 36 deletions
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 (inti = 0; i < k; ++i) {
7-
cnt[i] = newHashMap<>();
8-
}
9-
for (inti = 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 = newint[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 = newint[k];
7+
for (inti = 0; i < nums.length; ++i) {
8+
intj = i % k;
9+
cnt[j].merge(nums[i], 1, Integer::sum);
10+
size[j]++;
11+
}
12+
int[] f = newint[n];
13+
finalintinf = 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‎

Lines changed: 57 additions & 2 deletions
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‎

Lines changed: 57 additions & 2 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /