Skip to content

Commit 7749510

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0037
No.0037.Sudoku Solver
1 parent 141ff97 commit 7749510

File tree

6 files changed

+481
-42
lines changed

6 files changed

+481
-42
lines changed

‎solution/0000-0099/0037.Sudoku Solver/README.md

Lines changed: 173 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,22 +51,194 @@
5151

5252
<!-- 这里可写通用的实现逻辑 -->
5353

54+
**方法一：回溯**
55+
56+
我们用数组 `row`、`col`、`box` 分别记录每一行、每一列、每个 3x3 宫格中数字是否出现过。如果数字 `i` 在第 `r` 行、第 `c` 列、第 `b` 个 3x3 宫格中出现过，那么 `row[r][i]`、`col[c][i]`、`box[b][i]` 都为 `true`。
57+
58+
我们遍历 `board` 的每一个空格，枚举它可以填入的数字 `v`，如果 `v` 在当前行、当前列、当前 3x3 宫格中没有出现过，那么我们就可以尝试填入数字 `v`，并继续搜索下一个空格。如果搜索到最后，所有空格填充完毕，那么就说明找到了一个可行解。
59+
60+
时间复杂度 $O(9^{81})$，空间复杂度 $O(9^2)$。
61+
5462
<!-- tabs:start -->
5563

5664
### **Python3**
5765

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

6068
```python
61-
69+
class Solution:
70+
def solveSudoku(self, board: List[List[str]]) -> None:
71+
def dfs(k):
72+
nonlocal ok
73+
if k == len(t):
74+
ok = True
75+
return
76+
i, j = t[k]
77+
for v in range(9):
78+
if row[i][v] == col[j][v] == block[i // 3][j // 3][v] == False:
79+
row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True
80+
board[i][j] = str(v + 1)
81+
dfs(k + 1)
82+
row[i][v] = col[j][v] = block[i // 3][j // 3][v] = False
83+
if ok:
84+
return
85+
86+
row = [[False] * 9 for _ in range(9)]
87+
col = [[False] * 9 for _ in range(9)]
88+
block = [[[False] * 9 for _ in range(3)] for _ in range(3)]
89+
t = []
90+
ok = False
91+
for i in range(9):
92+
for j in range(9):
93+
if board[i][j] == '.':
94+
t.append((i, j))
95+
else:
96+
v = int(board[i][j]) - 1
97+
row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True
98+
dfs(0)
6299
```
63100

64101
### **Java**
65102

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

68105
```java
106+
class Solution {
107+
private boolean ok;
108+
private char[][] board;
109+
private List<Integer> t = new ArrayList<>();
110+
private boolean[][] row = new boolean[9][9];
111+
private boolean[][] col = new boolean[9][9];
112+
private boolean[][][] block = new boolean[3][3][9];
113+
114+
public void solveSudoku(char[][] board) {
115+
this.board = board;
116+
for (int i = 0; i < 9; ++i) {
117+
for (int j = 0; j < 9; ++j) {
118+
if (board[i][j] == '.') {
119+
t.add(i * 9 + j);
120+
} else {
121+
int v = board[i][j] - '1';
122+
row[i][v] = true;
123+
col[j][v] = true;
124+
block[i / 3][j / 3][v] = true;
125+
}
126+
}
127+
}
128+
dfs(0);
129+
}
130+
131+
private void dfs(int k) {
132+
if (k == t.size()) {
133+
ok = true;
134+
return;
135+
}
136+
int i = t.get(k) / 9, j = t.get(k) % 9;
137+
for (int v = 0; v < 9; ++v) {
138+
if (!row[i][v] && !col[j][v] && !block[i / 3][j / 3][v]) {
139+
row[i][v] = true;
140+
col[j][v] = true;
141+
block[i / 3][j / 3][v] = true;
142+
board[i][j] = (char) (v + '1');
143+
dfs(k + 1);
144+
row[i][v] = false;
145+
col[j][v] = false;
146+
block[i / 3][j / 3][v] = false;
147+
}
148+
if (ok) {
149+
return;
150+
}
151+
}
152+
}
153+
}
154+
```
155+
156+
### **C++**
157+
158+
```cpp
159+
using pii = pair<int, int>;
160+
161+
class Solution {
162+
public:
163+
void solveSudoku(vector<vector<char>>& board) {
164+
bool row[9][9] = {false};
165+
bool col[9][9] = {false};
166+
bool block[3][3][9] = {false};
167+
bool ok = false;
168+
vector<pii> t;
169+
for (int i = 0; i < 9; ++i) {
170+
for (int j = 0; j < 9; ++j) {
171+
if (board[i][j] == '.') {
172+
t.push_back({i, j});
173+
} else {
174+
int v = board[i][j] - '1';
175+
row[i][v] = col[j][v] = block[i / 3][j / 3][v] = true;
176+
}
177+
}
178+
}
179+
function<void(int k)> dfs;
180+
dfs = [&](int k) {
181+
if (k == t.size()) {
182+
ok = true;
183+
return;
184+
}
185+
int i = t[k].first, j = t[k].second;
186+
for (int v = 0; v < 9; ++v) {
187+
if (!row[i][v] && !col[j][v] && !block[i / 3][j / 3][v]) {
188+
row[i][v] = col[j][v] = block[i / 3][j / 3][v] = true;
189+
board[i][j] = v + '1';
190+
dfs(k + 1);
191+
row[i][v] = col[j][v] = block[i / 3][j / 3][v] = false;
192+
}
193+
if (ok) {
194+
return;
195+
}
196+
}
197+
};
198+
dfs(0);
199+
}
200+
};
201+
```
69202
203+
### **Go**
204+
205+
```go
206+
func solveSudoku(board [][]byte) {
207+
var row, col [9][9]bool
208+
var block [3][3][9]bool
209+
var t [][2]int
210+
ok := false
211+
for i := 0; i < 9; i++ {
212+
for j := 0; j < 9; j++ {
213+
if board[i][j] == '.' {
214+
t = append(t, [2]int{i, j})
215+
} else {
216+
v := int(board[i][j] - '1')
217+
row[i][v], col[j][v], block[i/3][j/3][v] = true, true, true
218+
}
219+
}
220+
}
221+
var dfs func(int)
222+
dfs = func(k int) {
223+
if k == len(t) {
224+
ok = true
225+
return
226+
}
227+
i, j := t[k][0], t[k][1]
228+
for v := 0; v < 9; v++ {
229+
if !row[i][v] && !col[j][v] && !block[i/3][j/3][v] {
230+
row[i][v], col[j][v], block[i/3][j/3][v] = true, true, true
231+
board[i][j] = byte(v + '1')
232+
dfs(k + 1)
233+
row[i][v], col[j][v], block[i/3][j/3][v] = false, false, false
234+
}
235+
if ok {
236+
return
237+
}
238+
}
239+
}
240+
dfs(0)
241+
}
70242
```
71243

72244
### **...**

‎solution/0000-0099/0037.Sudoku Solver/README_EN.md

Lines changed: 165 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,13 +44,177 @@
4444
### **Python3**
4545

4646
```python
47-
47+
class Solution:
48+
def solveSudoku(self, board: List[List[str]]) -> None:
49+
def dfs(k):
50+
nonlocal ok
51+
if k == len(t):
52+
ok = True
53+
return
54+
i, j = t[k]
55+
for v in range(9):
56+
if row[i][v] == col[j][v] == block[i // 3][j // 3][v] == False:
57+
row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True
58+
board[i][j] = str(v + 1)
59+
dfs(k + 1)
60+
row[i][v] = col[j][v] = block[i // 3][j // 3][v] = False
61+
if ok:
62+
return
63+
64+
row = [[False] * 9 for _ in range(9)]
65+
col = [[False] * 9 for _ in range(9)]
66+
block = [[[False] * 9 for _ in range(3)] for _ in range(3)]
67+
t = []
68+
ok = False
69+
for i in range(9):
70+
for j in range(9):
71+
if board[i][j] == '.':
72+
t.append((i, j))
73+
else:
74+
v = int(board[i][j]) - 1
75+
row[i][v] = col[j][v] = block[i // 3][j // 3][v] = True
76+
dfs(0)
4877
```
4978

5079
### **Java**
5180

5281
```java
82+
class Solution {
83+
private boolean ok;
84+
private char[][] board;
85+
private List<Integer> t = new ArrayList<>();
86+
private boolean[][] row = new boolean[9][9];
87+
private boolean[][] col = new boolean[9][9];
88+
private boolean[][][] block = new boolean[3][3][9];
89+
90+
public void solveSudoku(char[][] board) {
91+
this.board = board;
92+
for (int i = 0; i < 9; ++i) {
93+
for (int j = 0; j < 9; ++j) {
94+
if (board[i][j] == '.') {
95+
t.add(i * 9 + j);
96+
} else {
97+
int v = board[i][j] - '1';
98+
row[i][v] = true;
99+
col[j][v] = true;
100+
block[i / 3][j / 3][v] = true;
101+
}
102+
}
103+
}
104+
dfs(0);
105+
}
106+
107+
private void dfs(int k) {
108+
if (k == t.size()) {
109+
ok = true;
110+
return;
111+
}
112+
int i = t.get(k) / 9, j = t.get(k) % 9;
113+
for (int v = 0; v < 9; ++v) {
114+
if (!row[i][v] && !col[j][v] && !block[i / 3][j / 3][v]) {
115+
row[i][v] = true;
116+
col[j][v] = true;
117+
block[i / 3][j / 3][v] = true;
118+
board[i][j] = (char) (v + '1');
119+
dfs(k + 1);
120+
row[i][v] = false;
121+
col[j][v] = false;
122+
block[i / 3][j / 3][v] = false;
123+
}
124+
if (ok) {
125+
return;
126+
}
127+
}
128+
}
129+
}
130+
```
131+
132+
### **C++**
133+
134+
```cpp
135+
using pii = pair<int, int>;
136+
137+
class Solution {
138+
public:
139+
void solveSudoku(vector<vector<char>>& board) {
140+
bool row[9][9] = {false};
141+
bool col[9][9] = {false};
142+
bool block[3][3][9] = {false};
143+
bool ok = false;
144+
vector<pii> t;
145+
for (int i = 0; i < 9; ++i) {
146+
for (int j = 0; j < 9; ++j) {
147+
if (board[i][j] == '.') {
148+
t.push_back({i, j});
149+
} else {
150+
int v = board[i][j] - '1';
151+
row[i][v] = col[j][v] = block[i / 3][j / 3][v] = true;
152+
}
153+
}
154+
}
155+
function<void(int k)> dfs;
156+
dfs = [&](int k) {
157+
if (k == t.size()) {
158+
ok = true;
159+
return;
160+
}
161+
int i = t[k].first, j = t[k].second;
162+
for (int v = 0; v < 9; ++v) {
163+
if (!row[i][v] && !col[j][v] && !block[i / 3][j / 3][v]) {
164+
row[i][v] = col[j][v] = block[i / 3][j / 3][v] = true;
165+
board[i][j] = v + '1';
166+
dfs(k + 1);
167+
row[i][v] = col[j][v] = block[i / 3][j / 3][v] = false;
168+
}
169+
if (ok) {
170+
return;
171+
}
172+
}
173+
};
174+
dfs(0);
175+
}
176+
};
177+
```
53178
179+
### **Go**
180+
181+
```go
182+
func solveSudoku(board [][]byte) {
183+
var row, col [9][9]bool
184+
var block [3][3][9]bool
185+
var t [][2]int
186+
ok := false
187+
for i := 0; i < 9; i++ {
188+
for j := 0; j < 9; j++ {
189+
if board[i][j] == '.' {
190+
t = append(t, [2]int{i, j})
191+
} else {
192+
v := int(board[i][j] - '1')
193+
row[i][v], col[j][v], block[i/3][j/3][v] = true, true, true
194+
}
195+
}
196+
}
197+
var dfs func(int)
198+
dfs = func(k int) {
199+
if k == len(t) {
200+
ok = true
201+
return
202+
}
203+
i, j := t[k][0], t[k][1]
204+
for v := 0; v < 9; v++ {
205+
if !row[i][v] && !col[j][v] && !block[i/3][j/3][v] {
206+
row[i][v], col[j][v], block[i/3][j/3][v] = true, true, true
207+
board[i][j] = byte(v + '1')
208+
dfs(k + 1)
209+
row[i][v], col[j][v], block[i/3][j/3][v] = false, false, false
210+
}
211+
if ok {
212+
return
213+
}
214+
}
215+
}
216+
dfs(0)
217+
}
54218
```
55219

56220
### **...**

0 commit comments

Comments
 (0)