Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to content

Commit 9b1aa7b

Browse files
acbinacbin
authored
feat: add solutions to lc problems: No.1260+ (doocs#2437)
1 parent d4ba79c commit 9b1aa7b

File tree

11 files changed

+132
-219
lines changed

11 files changed

+132
-219
lines changed

‎solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ class FindElements {
1515
root->val = 0;
1616
dfs(root);
1717
}
18-
18+
1919
bool find(int target) {
2020
return s.contains(target);
2121
}

‎solution/1200-1299/1261.Find Elements in a Contaminated Binary Tree/Solution.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ public FindElements(TreeNode root) {
2020
root.val = 0;
2121
dfs(root);
2222
}
23-
23+
2424
public boolean find(int target) {
2525
return s.contains(target);
2626
}

‎solution/1200-1299/1282.Group the People Given the Group Size They Belong To/README.md

Lines changed: 34 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@
5555

5656
由于题目中的 $n$ 范围较小，我们也可以直接创建一个大小为 $n+1$ 的数组来存放数据，运行效率较高。
5757

58-
时间复杂度 $O(n)$，空间复杂度 $O(n)$。
58+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 $groupSizes$ 的长度。
5959

6060
<!-- tabs:start -->
6161

@@ -95,7 +95,9 @@ public:
9595
vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
9696
int n = groupSizes.size();
9797
vector<vector<int>> g(n + 1);
98-
for (int i = 0; i < n; ++i) g[groupSizes[i]].push_back(i);
98+
for (int i = 0; i < n; ++i) {
99+
g[groupSizes[i]].push_back(i);
100+
}
99101
vector<vector<int>> ans;
100102
for (int i = 0; i < g.size(); ++i) {
101103
for (int j = 0; j < g[i].size(); j += i) {
@@ -127,82 +129,49 @@ func groupThePeople(groupSizes []int) [][]int {
127129

128130
```ts
129131
function groupThePeople(groupSizes: number[]): number[][] {
130-
const res = [];
131-
const map = new Map<number, number[]>();
132-
const n = groupSizes.length;
133-
for (let i = 0; i < n; i++) {
134-
const size = groupSizes[i];
135-
map.set(size, [...(map.get(size) ?? []), i]);
136-
const arr = map.get(size);
137-
if (arr.length === size) {
138-
res.push(arr);
139-
map.set(size, []);
132+
const n: number = groupSizes.length;
133+
const g: number[][] = Array.from({ length: n + 1 }, () => []);
134+
135+
for (let i = 0; i < groupSizes.length; i++) {
136+
const size: number = groupSizes[i];
137+
g[size].push(i);
138+
}
139+
const ans: number[][] = [];
140+
for (let i = 1; i <= n; i++) {
141+
const group: number[] = [];
142+
for (let j = 0; j < g[i].length; j += i) {
143+
group.push(...g[i].slice(j, j + i));
144+
ans.push([...group]);
145+
group.length = 0;
140146
}
141147
}
142-
return res;
148+
return ans;
143149
}
144150
```
145151

146152
```rust
147-
use std::collections::HashMap;
148153
impl Solution {
149154
pub fn group_the_people(group_sizes: Vec<i32>) -> Vec<Vec<i32>> {
150-
let mut res = vec![];
151-
let mut map = HashMap::new();
152-
for i in 0..group_sizes.len() {
153-
let size = group_sizes[i] as usize;
154-
let arr = map.entry(size).or_insert(vec![]);
155-
arr.push(i as i32);
156-
if arr.len() == size {
157-
res.push(arr.clone());
158-
arr.clear();
159-
}
160-
}
161-
res
162-
}
163-
}
164-
```
165-
166-
<!-- tabs:end -->
167-
168-
### 方法二
155+
let n: usize = group_sizes.len();
156+
let mut g: Vec<Vec<usize>> = vec![Vec::new(); n + 1];
169157

170-
<!-- tabs:start -->
171-
172-
```python
173-
class Solution:
174-
def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]:
175-
g = defaultdict(list)
176-
for i, x in enumerate(groupSizes):
177-
g[x].append(i)
178-
ans = []
179-
for x, idx in g.items():
180-
t = []
181-
for i in idx:
182-
t.append(i)
183-
if len(t) == x:
184-
ans.append(t)
185-
t = []
186-
return ans
187-
```
158+
for (i, &size) in group_sizes.iter().enumerate() {
159+
g[size as usize].push(i);
160+
}
188161

189-
```rust
190-
impl Solution {
191-
#[allow(dead_code)]
192-
pub fn group_the_people(group_sizes: Vec<i32>) -> Vec<Vec<i32>> {
193-
let n = group_sizes.len();
194-
let mut g = vec![vec![]; n + 1];
195-
let mut ret = vec![];
196-
197-
for i in 0..n {
198-
g[group_sizes[i] as usize].push(i as i32);
199-
if g[group_sizes[i] as usize].len() == (group_sizes[i] as usize) {
200-
ret.push(g[group_sizes[i] as usize].clone());
201-
g[group_sizes[i] as usize].clear();
162+
let mut ans: Vec<Vec<i32>> = Vec::new();
163+
for (i, v) in g.into_iter().enumerate() {
164+
for j in (0..v.len()).step_by(i.max(1)) {
165+
ans.push(
166+
v[j..(j + i).min(v.len())]
167+
.iter()
168+
.map(|&x| x as i32)
169+
.collect()
170+
);
202171
}
203172
}
204173

205-
ret
174+
ans
206175
}
207176
}
208177
```

‎solution/1200-1299/1282.Group the People Given the Group Size They Belong To/README_EN.md

Lines changed: 40 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,13 @@ Other possible solutions are [[2,1,6],[5],[0,4,3]] and [[5],[0,6,2],[4,3,1]].
4545

4646
## Solutions
4747

48-
### Solution 1
48+
### Solution 1: Hash Table or Array
49+
50+
We use a hash table $g$ to store which people are in each group size $groupSize$. Then we partition each group size into $k$ equal parts, with each part containing $groupSize$ people.
51+
52+
Since the range of $n$ in the problem is small, we can also directly create an array of size $n+1$ to store the data, which is more efficient.
53+
54+
Time complexity is $O(n)$, and space complexity is $O(n)$. Here, $n$ is the length of $groupSizes$.
4955

5056
<!-- tabs:start -->
5157

@@ -85,7 +91,9 @@ public:
8591
vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
8692
int n = groupSizes.size();
8793
vector<vector<int>> g(n + 1);
88-
for (int i = 0; i < n; ++i) g[groupSizes[i]].push_back(i);
94+
for (int i = 0; i < n; ++i) {
95+
g[groupSizes[i]].push_back(i);
96+
}
8997
vector<vector<int>> ans;
9098
for (int i = 0; i < g.size(); ++i) {
9199
for (int j = 0; j < g[i].size(); j += i) {
@@ -117,82 +125,49 @@ func groupThePeople(groupSizes []int) [][]int {
117125

118126
```ts
119127
function groupThePeople(groupSizes: number[]): number[][] {
120-
const res = [];
121-
const map = new Map<number, number[]>();
122-
const n = groupSizes.length;
123-
for (let i = 0; i < n; i++) {
124-
const size = groupSizes[i];
125-
map.set(size, [...(map.get(size) ?? []), i]);
126-
const arr = map.get(size);
127-
if (arr.length === size) {
128-
res.push(arr);
129-
map.set(size, []);
128+
const n: number = groupSizes.length;
129+
const g: number[][] = Array.from({ length: n + 1 }, () => []);
130+
131+
for (let i = 0; i < groupSizes.length; i++) {
132+
const size: number = groupSizes[i];
133+
g[size].push(i);
134+
}
135+
const ans: number[][] = [];
136+
for (let i = 1; i <= n; i++) {
137+
const group: number[] = [];
138+
for (let j = 0; j < g[i].length; j += i) {
139+
group.push(...g[i].slice(j, j + i));
140+
ans.push([...group]);
141+
group.length = 0;
130142
}
131143
}
132-
return res;
144+
return ans;
133145
}
134146
```
135147

136148
```rust
137-
use std::collections::HashMap;
138149
impl Solution {
139150
pub fn group_the_people(group_sizes: Vec<i32>) -> Vec<Vec<i32>> {
140-
let mut res = vec![];
141-
let mut map = HashMap::new();
142-
for i in 0..group_sizes.len() {
143-
let size = group_sizes[i] as usize;
144-
let arr = map.entry(size).or_insert(vec![]);
145-
arr.push(i as i32);
146-
if arr.len() == size {
147-
res.push(arr.clone());
148-
arr.clear();
149-
}
150-
}
151-
res
152-
}
153-
}
154-
```
155-
156-
<!-- tabs:end -->
157-
158-
### Solution 2
159-
160-
<!-- tabs:start -->
151+
let n: usize = group_sizes.len();
152+
let mut g: Vec<Vec<usize>> = vec![Vec::new(); n + 1];
161153

162-
```python
163-
class Solution:
164-
def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]:
165-
g = defaultdict(list)
166-
for i, x in enumerate(groupSizes):
167-
g[x].append(i)
168-
ans = []
169-
for x, idx in g.items():
170-
t = []
171-
for i in idx:
172-
t.append(i)
173-
if len(t) == x:
174-
ans.append(t)
175-
t = []
176-
return ans
177-
```
154+
for (i, &size) in group_sizes.iter().enumerate() {
155+
g[size as usize].push(i);
156+
}
178157

179-
```rust
180-
impl Solution {
181-
#[allow(dead_code)]
182-
pub fn group_the_people(group_sizes: Vec<i32>) -> Vec<Vec<i32>> {
183-
let n = group_sizes.len();
184-
let mut g = vec![vec![]; n + 1];
185-
let mut ret = vec![];
186-
187-
for i in 0..n {
188-
g[group_sizes[i] as usize].push(i as i32);
189-
if g[group_sizes[i] as usize].len() == (group_sizes[i] as usize) {
190-
ret.push(g[group_sizes[i] as usize].clone());
191-
g[group_sizes[i] as usize].clear();
158+
let mut ans: Vec<Vec<i32>> = Vec::new();
159+
for (i, v) in g.into_iter().enumerate() {
160+
for j in (0..v.len()).step_by(i.max(1)) {
161+
ans.push(
162+
v[j..(j + i).min(v.len())]
163+
.iter()
164+
.map(|&x| x as i32)
165+
.collect()
166+
);
192167
}
193168
}
194169

195-
ret
170+
ans
196171
}
197172
}
198173
```

‎solution/1200-1299/1282.Group the People Given the Group Size They Belong To/Solution.cpp

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,9 @@ class Solution {
33
vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
44
int n = groupSizes.size();
55
vector<vector<int>> g(n + 1);
6-
for (int i = 0; i < n; ++i) g[groupSizes[i]].push_back(i);
6+
for (int i = 0; i < n; ++i) {
7+
g[groupSizes[i]].push_back(i);
8+
}
79
vector<vector<int>> ans;
810
for (int i = 0; i < g.size(); ++i) {
911
for (int j = 0; j < g[i].size(); j += i) {

‎solution/1200-1299/1282.Group the People Given the Group Size They Belong To/Solution.rs

Lines changed: 18 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,24 @@
1-
use std::collections::HashMap;
21
impl Solution {
32
pub fn group_the_people(group_sizes: Vec<i32>) -> Vec<Vec<i32>> {
4-
let mut res = vec![];
5-
let mut map = HashMap::new();
6-
for i in 0..group_sizes.len() {
7-
let size = group_sizes[i] as usize;
8-
let arr = map.entry(size).or_insert(vec![]);
9-
arr.push(i as i32);
10-
if arr.len() == size {
11-
res.push(arr.clone());
12-
arr.clear();
3+
let n: usize = group_sizes.len();
4+
let mut g: Vec<Vec<usize>> = vec![Vec::new(); n + 1];
5+
6+
for (i, &size) in group_sizes.iter().enumerate() {
7+
g[size as usize].push(i);
8+
}
9+
10+
let mut ans: Vec<Vec<i32>> = Vec::new();
11+
for (i, v) in g.into_iter().enumerate() {
12+
for j in (0..v.len()).step_by(i.max(1)) {
13+
ans.push(
14+
v[j..(j + i).min(v.len())]
15+
.iter()
16+
.map(|&x| x as i32)
17+
.collect()
18+
);
1319
}
1420
}
15-
res
21+
22+
ans
1623
}
1724
}

‎solution/1200-1299/1282.Group the People Given the Group Size They Belong To/Solution.ts

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,19 @@
11
function groupThePeople(groupSizes: number[]): number[][] {
2-
const res = [];
3-
const map = new Map<number, number[]>();
4-
const n = groupSizes.length;
5-
for (let i = 0; i < n; i++) {
6-
const size = groupSizes[i];
7-
map.set(size, [...(map.get(size) ?? []), i]);
8-
const arr = map.get(size);
9-
if (arr.length === size) {
10-
res.push(arr);
11-
map.set(size, []);
2+
const n: number = groupSizes.length;
3+
const g: number[][] = Array.from({ length: n + 1 }, () => []);
4+
5+
for (let i = 0; i < groupSizes.length; i++) {
6+
const size: number = groupSizes[i];
7+
g[size].push(i);
8+
}
9+
const ans: number[][] = [];
10+
for (let i = 1; i <= n; i++) {
11+
const group: number[] = [];
12+
for (let j = 0; j < g[i].length; j += i) {
13+
group.push(...g[i].slice(j, j + i));
14+
ans.push([...group]);
15+
group.length = 0;
1216
}
1317
}
14-
return res;
18+
return ans;
1519
}

‎solution/1200-1299/1282.Group the People Given the Group Size They Belong To/Solution2.py

Lines changed: 0 additions & 14 deletions
This file was deleted.

0 commit comments

Comments
 (0)