Skip to content

Commit 5c1cbd7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems
* No.1284.Minimum Number of Flips to Convert Binary Matrix to Zero Matrix * No.2174.Remove All Ones With Row and Column Flips II
1 parent 5510b0e commit 5c1cbd7

File tree

12 files changed

+1018
-4
lines changed

12 files changed

+1018
-4
lines changed

‎solution/1200-1299/1284.Minimum Number of Flips to Convert Binary Matrix to Zero Matrix/README.md

Lines changed: 181 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,22 +58,202 @@
5858

5959
<!-- 这里可写通用的实现逻辑 -->
6060

61+
**方法一：状态压缩 + BFS**
62+
6163
<!-- tabs:start -->
6264

6365
### **Python3**
6466

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

6769
```python
68-
70+
class Solution:
71+
def minFlips(self, mat: List[List[int]]) -> int:
72+
m, n = len(mat), len(mat[0])
73+
state = sum(1 << (i * n + j) for i in range(m)
74+
for j in range(n) if mat[i][j])
75+
q = deque([state])
76+
vis = set([state])
77+
ans = 0
78+
dirs = [0, -1, 0, 1, 0, 0]
79+
while q:
80+
for _ in range(len(q)):
81+
state = q.popleft()
82+
if state == 0:
83+
return ans
84+
for i in range(m):
85+
for j in range(n):
86+
nxt = state
87+
for k in range(5):
88+
x, y = i + dirs[k], j + dirs[k + 1]
89+
if not 0 <= x < m or not 0 <= y < n:
90+
continue
91+
if nxt & (1 << (x * n + y)):
92+
nxt -= 1 << (x * n + y)
93+
else:
94+
nxt |= 1 << (x * n + y)
95+
if nxt not in vis:
96+
vis.add(nxt)
97+
q.append(nxt)
98+
ans += 1
99+
return -1
69100
```
70101

71102
### **Java**
72103

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

75106
```java
107+
class Solution {
108+
public int minFlips(int[][] mat) {
109+
int m = mat.length, n = mat[0].length;
110+
int state = 0;
111+
for (int i = 0; i < m; ++i) {
112+
for (int j = 0; j < n; ++j) {
113+
if (mat[i][j] == 1) {
114+
state |= 1 << (i * n + j);
115+
}
116+
}
117+
}
118+
Deque<Integer> q = new ArrayDeque<>();
119+
q.offer(state);
120+
Set<Integer> vis = new HashSet<>();
121+
vis.add(state);
122+
int ans = 0;
123+
int[] dirs = {0, -1, 0, 1, 0, 0};
124+
while (!q.isEmpty()) {
125+
for (int t = q.size(); t > 0; --t) {
126+
state = q.poll();
127+
if (state == 0) {
128+
return ans;
129+
}
130+
for (int i = 0; i < m; ++i) {
131+
for (int j = 0; j < n; ++j) {
132+
int nxt = state;
133+
for (int k = 0; k < 5; ++k) {
134+
int x = i + dirs[k], y = j + dirs[k + 1];
135+
if (x < 0 || x >= m || y < 0 || y >= n) {
136+
continue;
137+
}
138+
if ((nxt & (1 << (x * n + y))) != 0) {
139+
nxt -= 1 << (x * n + y);
140+
} else {
141+
nxt |= 1 << (x * n + y);
142+
}
143+
}
144+
if (!vis.contains(nxt)) {
145+
vis.add(nxt);
146+
q.offer(nxt);
147+
}
148+
}
149+
}
150+
}
151+
++ans;
152+
}
153+
return -1;
154+
}
155+
}
156+
```
157+
158+
### **C++**
159+
160+
```cpp
161+
class Solution {
162+
public:
163+
int minFlips(vector<vector<int>>& mat) {
164+
int m = mat.size(), n = mat[0].size();
165+
int state = 0;
166+
for (int i = 0; i < m; ++i)
167+
for (int j = 0; j < n; ++j)
168+
if (mat[i][j])
169+
state |= (1 << (i * n + j));
170+
queue<int> q{{state}};
171+
unordered_set<int> vis{{state}};
172+
int ans = 0;
173+
vector<int> dirs = {0, -1, 0, 1, 0, 0};
174+
while (!q.empty())
175+
{
176+
for (int t = q.size(); t; --t)
177+
{
178+
state = q.front();
179+
if (state == 0) return ans;
180+
q.pop();
181+
for (int i = 0; i < m; ++i)
182+
{
183+
for (int j = 0; j < n; ++j)
184+
{
185+
int nxt = state;
186+
for (int k = 0; k < 5; ++k)
187+
{
188+
int x = i + dirs[k], y = j + dirs[k + 1];
189+
if (x < 0 || x >= m || y < 0 || y >= n) continue;
190+
if ((nxt & (1 << (x * n + y))) != 0) nxt -= 1 << (x * n + y);
191+
else nxt |= 1 << (x * n + y);
192+
}
193+
if (!vis.count(nxt))
194+
{
195+
vis.insert(nxt);
196+
q.push(nxt);
197+
}
198+
}
199+
}
200+
}
201+
++ans;
202+
}
203+
return -1;
204+
}
205+
};
206+
```
76207
208+
### **Go**
209+
210+
```go
211+
func minFlips(mat [][]int) int {
212+
m, n := len(mat), len(mat[0])
213+
state := 0
214+
for i, row := range mat {
215+
for j, v := range row {
216+
if v == 1 {
217+
state |= 1 << (i*n + j)
218+
}
219+
}
220+
}
221+
q := []int{state}
222+
vis := map[int]bool{state: true}
223+
ans := 0
224+
dirs := []int{0, -1, 0, 1, 0, 0}
225+
for len(q) > 0 {
226+
for t := len(q); t > 0; t-- {
227+
state = q[0]
228+
if state == 0 {
229+
return ans
230+
}
231+
q = q[1:]
232+
for i := 0; i < m; i++ {
233+
for j := 0; j < n; j++ {
234+
nxt := state
235+
for k := 0; k < 5; k++ {
236+
x, y := i+dirs[k], j+dirs[k+1]
237+
if x < 0 || x >= m || y < 0 || y >= n {
238+
continue
239+
}
240+
if (nxt & (1 << (x*n + y))) != 0 {
241+
nxt -= 1 << (x*n + y)
242+
} else {
243+
nxt |= 1 << (x*n + y)
244+
}
245+
}
246+
if !vis[nxt] {
247+
vis[nxt] = true
248+
q = append(q, nxt)
249+
}
250+
}
251+
}
252+
}
253+
ans++
254+
}
255+
return -1
256+
}
77257
```
78258

79259
### **...**

‎solution/1200-1299/1284.Minimum Number of Flips to Convert Binary Matrix to Zero Matrix/README_EN.md

Lines changed: 179 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -54,13 +54,191 @@
5454
### **Python3**
5555

5656
```python
57-
57+
class Solution:
58+
def minFlips(self, mat: List[List[int]]) -> int:
59+
m, n = len(mat), len(mat[0])
60+
state = sum(1 << (i * n + j) for i in range(m)
61+
for j in range(n) if mat[i][j])
62+
q = deque([state])
63+
vis = set([state])
64+
ans = 0
65+
dirs = [0, -1, 0, 1, 0, 0]
66+
while q:
67+
for _ in range(len(q)):
68+
state = q.popleft()
69+
if state == 0:
70+
return ans
71+
for i in range(m):
72+
for j in range(n):
73+
nxt = state
74+
for k in range(5):
75+
x, y = i + dirs[k], j + dirs[k + 1]
76+
if not 0 <= x < m or not 0 <= y < n:
77+
continue
78+
if nxt & (1 << (x * n + y)):
79+
nxt -= 1 << (x * n + y)
80+
else:
81+
nxt |= 1 << (x * n + y)
82+
if nxt not in vis:
83+
vis.add(nxt)
84+
q.append(nxt)
85+
ans += 1
86+
return -1
5887
```
5988

6089
### **Java**
6190

6291
```java
92+
class Solution {
93+
public int minFlips(int[][] mat) {
94+
int m = mat.length, n = mat[0].length;
95+
int state = 0;
96+
for (int i = 0; i < m; ++i) {
97+
for (int j = 0; j < n; ++j) {
98+
if (mat[i][j] == 1) {
99+
state |= 1 << (i * n + j);
100+
}
101+
}
102+
}
103+
Deque<Integer> q = new ArrayDeque<>();
104+
q.offer(state);
105+
Set<Integer> vis = new HashSet<>();
106+
vis.add(state);
107+
int ans = 0;
108+
int[] dirs = {0, -1, 0, 1, 0, 0};
109+
while (!q.isEmpty()) {
110+
for (int t = q.size(); t > 0; --t) {
111+
state = q.poll();
112+
if (state == 0) {
113+
return ans;
114+
}
115+
for (int i = 0; i < m; ++i) {
116+
for (int j = 0; j < n; ++j) {
117+
int nxt = state;
118+
for (int k = 0; k < 5; ++k) {
119+
int x = i + dirs[k], y = j + dirs[k + 1];
120+
if (x < 0 || x >= m || y < 0 || y >= n) {
121+
continue;
122+
}
123+
if ((nxt & (1 << (x * n + y))) != 0) {
124+
nxt -= 1 << (x * n + y);
125+
} else {
126+
nxt |= 1 << (x * n + y);
127+
}
128+
}
129+
if (!vis.contains(nxt)) {
130+
vis.add(nxt);
131+
q.offer(nxt);
132+
}
133+
}
134+
}
135+
}
136+
++ans;
137+
}
138+
return -1;
139+
}
140+
}
141+
```
142+
143+
### **C++**
144+
145+
```cpp
146+
class Solution {
147+
public:
148+
int minFlips(vector<vector<int>>& mat) {
149+
int m = mat.size(), n = mat[0].size();
150+
int state = 0;
151+
for (int i = 0; i < m; ++i)
152+
for (int j = 0; j < n; ++j)
153+
if (mat[i][j])
154+
state |= (1 << (i * n + j));
155+
queue<int> q{{state}};
156+
unordered_set<int> vis{{state}};
157+
int ans = 0;
158+
vector<int> dirs = {0, -1, 0, 1, 0, 0};
159+
while (!q.empty())
160+
{
161+
for (int t = q.size(); t; --t)
162+
{
163+
state = q.front();
164+
if (state == 0) return ans;
165+
q.pop();
166+
for (int i = 0; i < m; ++i)
167+
{
168+
for (int j = 0; j < n; ++j)
169+
{
170+
int nxt = state;
171+
for (int k = 0; k < 5; ++k)
172+
{
173+
int x = i + dirs[k], y = j + dirs[k + 1];
174+
if (x < 0 || x >= m || y < 0 || y >= n) continue;
175+
if ((nxt & (1 << (x * n + y))) != 0) nxt -= 1 << (x * n + y);
176+
else nxt |= 1 << (x * n + y);
177+
}
178+
if (!vis.count(nxt))
179+
{
180+
vis.insert(nxt);
181+
q.push(nxt);
182+
}
183+
}
184+
}
185+
}
186+
++ans;
187+
}
188+
return -1;
189+
}
190+
};
191+
```
63192
193+
### **Go**
194+
195+
```go
196+
func minFlips(mat [][]int) int {
197+
m, n := len(mat), len(mat[0])
198+
state := 0
199+
for i, row := range mat {
200+
for j, v := range row {
201+
if v == 1 {
202+
state |= 1 << (i*n + j)
203+
}
204+
}
205+
}
206+
q := []int{state}
207+
vis := map[int]bool{state: true}
208+
ans := 0
209+
dirs := []int{0, -1, 0, 1, 0, 0}
210+
for len(q) > 0 {
211+
for t := len(q); t > 0; t-- {
212+
state = q[0]
213+
if state == 0 {
214+
return ans
215+
}
216+
q = q[1:]
217+
for i := 0; i < m; i++ {
218+
for j := 0; j < n; j++ {
219+
nxt := state
220+
for k := 0; k < 5; k++ {
221+
x, y := i+dirs[k], j+dirs[k+1]
222+
if x < 0 || x >= m || y < 0 || y >= n {
223+
continue
224+
}
225+
if (nxt & (1 << (x*n + y))) != 0 {
226+
nxt -= 1 << (x*n + y)
227+
} else {
228+
nxt |= 1 << (x*n + y)
229+
}
230+
}
231+
if !vis[nxt] {
232+
vis[nxt] = true
233+
q = append(q, nxt)
234+
}
235+
}
236+
}
237+
}
238+
ans++
239+
}
240+
return -1
241+
}
64242
```
65243

66244
### **...**

0 commit comments

Comments
 (0)