LeetCode 37 Sudoku Solver

题意：

给出一个一定有解的填了一部分的数独，要求填满它。

思路：

我是分2步解决这个问题的：

第1步检查每个格子可能填哪几个数字，第2步dfs搜索结果。

dfs的时候只搜索第1步中找出的可能的数字，每次尝试填入一个格子并更新当前行、当前列、当前3*3格子的可选数字，注意回溯。

我的代码3ms就可以跑完，效率还是很不错的。

代码：

class Solution {
public:
void solveSudoku(vector<vector<char>> &board) {
can.clear();
int besti = 0, bestj = 0, bestcnt = 10;
for (int i = 0; i < n; ++i) {
vector<set<int>> tmp;
for (int j = 0; j < n; ++j) {
if (board[i][j] != '.') {
tmp.push_back(set<int> {});
continue;
}
set<int> now = candidate(i, j, board);
int cnt = now.size();
// if(cnt == 1){
// board[i][j] = *(now.begin()) + '1';
// tmp.push_back(set<int>{});
// continue;
// }
tmp.push_back(now);
if (cnt < bestcnt) {
besti = i;
bestj = j;
bestcnt = cnt;
}
}
can.push_back(tmp);
}

if (bestcnt != 10) {
if (dfs(besti, bestj, board)) {
printf("success!");
} else {
printf("fuck!");
}
}
}

private:
int n = 9;
vector<vector<set<int>>> can;

set<int> candidate(int i, int j, vector<vector<char>> &board) {
bool app[9];
memset(app, false, sizeof(app));
for (int k = 0; k < n; ++k) {
if (board[i][k] != '.') {
app[board[i][k] - '1'] = true;
}
if (board[k][j] != '.') {
app[board[k][j] - '1'] = true;
}
int di = i / 3 * 3 + k / 3, dj = j / 3 * 3 + k % 3;
if (board[di][dj] != '.') {
app[board[di][dj] - '1'] = true;
}
}

set<int> res;
for (int k = 0; k < n; ++k) {
if (!app[k]) {
res.insert(k);
}
}
return res;
}

bool dfs(int x, int y, vector<vector<char>> &board) {
stack<pair<int, int>> effect;
set<int> now = can[x][y];
can[x][y].clear();
for (int k : now) {
// printf("%d %d %d\n", x + 1, y + 1, k + 1);
board[x][y] = k + '1';
for (int i = 0; i < n; ++i) {
if (i != y && can[x][i].find(k) != can[x][i].end()) {
can[x][i].erase(k);
effect.push(make_pair(x, i));
}
if (i != x && can[i][y].find(k) != can[i][y].end()) {
can[i][y].erase(k);
effect.push(make_pair(i, y));
}
int di = x / 3 * 3 + i / 3, dj = y / 3 * 3 + i % 3;
if (can[di][dj].find(k) != can[di][dj].end()) {
can[di][dj].erase(k);
effect.push(make_pair(di, dj));
}
}
int besti = 0, bestj = 0, bestcnt = 10;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (board[i][j] == '.' && can[i][j].size() < bestcnt) {
besti = i;
bestj = j;
bestcnt = can[i][j].size();
}
}
}
if (bestcnt != 0) {
if (bestcnt == 10 || dfs(besti, bestj, board)) {
return true;
}
}
while (!effect.empty()) {
pair<int, int> e = effect.top();
effect.pop();
can[e.first][e.second].insert(k);
}
}
board[x][y] = '.';
can[x][y] = now;
return false;
}
};