Skip to content

Commit 76e854a

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2732 (#3141)
No.2732.Find a Good Subset of the Matrix
1 parent c28dbd6 commit 76e854a

File tree

8 files changed

+420
-6
lines changed

8 files changed

+420
-6
lines changed

Diff for: ‎solution/2700-2799/2732.Find a Good Subset of the Matrix/README.md

+143-3
Original file line numberDiff line numberDiff line change
@@ -91,25 +91,165 @@ tags:
9191
#### Python3
9292

9393
```python
94-
94+
class Solution:
95+
def goodSubsetofBinaryMatrix(self, grid: List[List[int]]) -> List[int]:
96+
g = {}
97+
for i, row in enumerate(grid):
98+
mask = 0
99+
for j, x in enumerate(row):
100+
mask |= x << j
101+
if mask == 0:
102+
return [i]
103+
g[mask] = i
104+
for a, i in g.items():
105+
for b, j in g.items():
106+
if (a & b) == 0:
107+
return sorted([i, j])
108+
return []
95109
```
96110

97111
#### Java
98112

99113
```java
100-
114+
class Solution {
115+
public List<Integer> goodSubsetofBinaryMatrix(int[][] grid) {
116+
Map<Integer, Integer> g = new HashMap<>();
117+
for (int i = 0; i < grid.length; ++i) {
118+
int mask = 0;
119+
for (int j = 0; j < grid[0].length; ++j) {
120+
mask |= grid[i][j] << j;
121+
}
122+
if (mask == 0) {
123+
return List.of(i);
124+
}
125+
g.put(mask, i);
126+
}
127+
for (var e1 : g.entrySet()) {
128+
for (var e2 : g.entrySet()) {
129+
if ((e1.getKey() & e2.getKey()) == 0) {
130+
int i = e1.getValue(), j = e2.getValue();
131+
return List.of(Math.min(i, j), Math.max(i, j));
132+
}
133+
}
134+
}
135+
return List.of();
136+
}
137+
}
101138
```
102139

103140
#### C++
104141

105142
```cpp
106-
143+
class Solution {
144+
public:
145+
vector<int> goodSubsetofBinaryMatrix(vector<vector<int>>& grid) {
146+
unordered_map<int, int> g;
147+
for (int i = 0; i < grid.size(); ++i) {
148+
int mask = 0;
149+
for (int j = 0; j < grid[0].size(); ++j) {
150+
mask |= grid[i][j] << j;
151+
}
152+
if (mask == 0) {
153+
return {i};
154+
}
155+
g[mask] = i;
156+
}
157+
for (auto& [a, i] : g) {
158+
for (auto& [b, j] : g) {
159+
if ((a & b) == 0) {
160+
return {min(i, j), max(i, j)};
161+
}
162+
}
163+
}
164+
return {};
165+
}
166+
};
107167
```
108168
109169
#### Go
110170
111171
```go
172+
func goodSubsetofBinaryMatrix(grid [][]int) []int {
173+
g := map[int]int{}
174+
for i, row := range grid {
175+
mask := 0
176+
for j, x := range row {
177+
mask |= x << j
178+
}
179+
if mask == 0 {
180+
return []int{i}
181+
}
182+
g[mask] = i
183+
}
184+
for a, i := range g {
185+
for b, j := range g {
186+
if a&b == 0 {
187+
return []int{min(i, j), max(i, j)}
188+
}
189+
}
190+
}
191+
return []int{}
192+
}
193+
```
194+
195+
#### TypeScript
196+
197+
```ts
198+
function goodSubsetofBinaryMatrix(grid: number[][]): number[] {
199+
const g: Map<number, number> = new Map();
200+
const m = grid.length;
201+
const n = grid[0].length;
202+
for (let i = 0; i < m; ++i) {
203+
let mask = 0;
204+
for (let j = 0; j < n; ++j) {
205+
mask |= grid[i][j] << j;
206+
}
207+
if (!mask) {
208+
return [i];
209+
}
210+
g.set(mask, i);
211+
}
212+
for (const [a, i] of g.entries()) {
213+
for (const [b, j] of g.entries()) {
214+
if ((a & b) === 0) {
215+
return [Math.min(i, j), Math.max(i, j)];
216+
}
217+
}
218+
}
219+
return [];
220+
}
221+
```
112222

223+
#### Rust
224+
225+
```rust
226+
use std::collections::HashMap;
227+
228+
impl Solution {
229+
pub fn good_subsetof_binary_matrix(grid: Vec<Vec<i32>>) -> Vec<i32> {
230+
let mut g: HashMap<i32, i32> = HashMap::new();
231+
for (i, row) in grid.iter().enumerate() {
232+
let mut mask = 0;
233+
for (j, &x) in row.iter().enumerate() {
234+
mask |= x << j;
235+
}
236+
if mask == 0 {
237+
return vec![i as i32];
238+
}
239+
g.insert(mask, i as i32);
240+
}
241+
242+
for (&a, &i) in g.iter() {
243+
for (&b, &j) in g.iter() {
244+
if (a & b) == 0 {
245+
return vec![i.min(j), i.max(j)];
246+
}
247+
}
248+
}
249+
250+
vec![]
251+
}
252+
}
113253
```
114254

115255
<!-- tabs:end -->

Diff for: ‎solution/2700-2799/2732.Find a Good Subset of the Matrix/README_EN.md

+143-3
Original file line numberDiff line numberDiff line change
@@ -89,25 +89,165 @@ The length of the chosen subset is 1.
8989
#### Python3
9090

9191
```python
92-
92+
class Solution:
93+
def goodSubsetofBinaryMatrix(self, grid: List[List[int]]) -> List[int]:
94+
g = {}
95+
for i, row in enumerate(grid):
96+
mask = 0
97+
for j, x in enumerate(row):
98+
mask |= x << j
99+
if mask == 0:
100+
return [i]
101+
g[mask] = i
102+
for a, i in g.items():
103+
for b, j in g.items():
104+
if (a & b) == 0:
105+
return sorted([i, j])
106+
return []
93107
```
94108

95109
#### Java
96110

97111
```java
98-
112+
class Solution {
113+
public List<Integer> goodSubsetofBinaryMatrix(int[][] grid) {
114+
Map<Integer, Integer> g = new HashMap<>();
115+
for (int i = 0; i < grid.length; ++i) {
116+
int mask = 0;
117+
for (int j = 0; j < grid[0].length; ++j) {
118+
mask |= grid[i][j] << j;
119+
}
120+
if (mask == 0) {
121+
return List.of(i);
122+
}
123+
g.put(mask, i);
124+
}
125+
for (var e1 : g.entrySet()) {
126+
for (var e2 : g.entrySet()) {
127+
if ((e1.getKey() & e2.getKey()) == 0) {
128+
int i = e1.getValue(), j = e2.getValue();
129+
return List.of(Math.min(i, j), Math.max(i, j));
130+
}
131+
}
132+
}
133+
return List.of();
134+
}
135+
}
99136
```
100137

101138
#### C++
102139

103140
```cpp
104-
141+
class Solution {
142+
public:
143+
vector<int> goodSubsetofBinaryMatrix(vector<vector<int>>& grid) {
144+
unordered_map<int, int> g;
145+
for (int i = 0; i < grid.size(); ++i) {
146+
int mask = 0;
147+
for (int j = 0; j < grid[0].size(); ++j) {
148+
mask |= grid[i][j] << j;
149+
}
150+
if (mask == 0) {
151+
return {i};
152+
}
153+
g[mask] = i;
154+
}
155+
for (auto& [a, i] : g) {
156+
for (auto& [b, j] : g) {
157+
if ((a & b) == 0) {
158+
return {min(i, j), max(i, j)};
159+
}
160+
}
161+
}
162+
return {};
163+
}
164+
};
105165
```
106166
107167
#### Go
108168
109169
```go
170+
func goodSubsetofBinaryMatrix(grid [][]int) []int {
171+
g := map[int]int{}
172+
for i, row := range grid {
173+
mask := 0
174+
for j, x := range row {
175+
mask |= x << j
176+
}
177+
if mask == 0 {
178+
return []int{i}
179+
}
180+
g[mask] = i
181+
}
182+
for a, i := range g {
183+
for b, j := range g {
184+
if a&b == 0 {
185+
return []int{min(i, j), max(i, j)}
186+
}
187+
}
188+
}
189+
return []int{}
190+
}
191+
```
192+
193+
#### TypeScript
194+
195+
```ts
196+
function goodSubsetofBinaryMatrix(grid: number[][]): number[] {
197+
const g: Map<number, number> = new Map();
198+
const m = grid.length;
199+
const n = grid[0].length;
200+
for (let i = 0; i < m; ++i) {
201+
let mask = 0;
202+
for (let j = 0; j < n; ++j) {
203+
mask |= grid[i][j] << j;
204+
}
205+
if (!mask) {
206+
return [i];
207+
}
208+
g.set(mask, i);
209+
}
210+
for (const [a, i] of g.entries()) {
211+
for (const [b, j] of g.entries()) {
212+
if ((a & b) === 0) {
213+
return [Math.min(i, j), Math.max(i, j)];
214+
}
215+
}
216+
}
217+
return [];
218+
}
219+
```
110220

221+
#### Rust
222+
223+
```rust
224+
use std::collections::HashMap;
225+
226+
impl Solution {
227+
pub fn good_subsetof_binary_matrix(grid: Vec<Vec<i32>>) -> Vec<i32> {
228+
let mut g: HashMap<i32, i32> = HashMap::new();
229+
for (i, row) in grid.iter().enumerate() {
230+
let mut mask = 0;
231+
for (j, &x) in row.iter().enumerate() {
232+
mask |= x << j;
233+
}
234+
if mask == 0 {
235+
return vec![i as i32];
236+
}
237+
g.insert(mask, i as i32);
238+
}
239+
240+
for (&a, &i) in g.iter() {
241+
for (&b, &j) in g.iter() {
242+
if (a & b) == 0 {
243+
return vec![i.min(j), i.max(j)];
244+
}
245+
}
246+
}
247+
248+
vec![]
249+
}
250+
}
111251
```
112252

113253
<!-- tabs:end -->

Diff for: ‎solution/2700-2799/2732.Find a Good Subset of the Matrix/Solution.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
vector<int> goodSubsetofBinaryMatrix(vector<vector<int>>& grid) {
4+
unordered_map<int, int> g;
5+
for (int i = 0; i < grid.size(); ++i) {
6+
int mask = 0;
7+
for (int j = 0; j < grid[0].size(); ++j) {
8+
mask |= grid[i][j] << j;
9+
}
10+
if (mask == 0) {
11+
return {i};
12+
}
13+
g[mask] = i;
14+
}
15+
for (auto& [a, i] : g) {
16+
for (auto& [b, j] : g) {
17+
if ((a & b) == 0) {
18+
return {min(i, j), max(i, j)};
19+
}
20+
}
21+
}
22+
return {};
23+
}
24+
};

Diff for: ‎solution/2700-2799/2732.Find a Good Subset of the Matrix/Solution.go

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
func goodSubsetofBinaryMatrix(grid [][]int) []int {
2+
g := map[int]int{}
3+
for i, row := range grid {
4+
mask := 0
5+
for j, x := range row {
6+
mask |= x << j
7+
}
8+
if mask == 0 {
9+
return []int{i}
10+
}
11+
g[mask] = i
12+
}
13+
for a, i := range g {
14+
for b, j := range g {
15+
if a&b == 0 {
16+
return []int{min(i, j), max(i, j)}
17+
}
18+
}
19+
}
20+
return []int{}
21+
}

0 commit comments

Comments
 (0)