[dfs] aw166. 数独(dfs剪枝与优化+状态压缩+代码技巧+好题)

Posted 2021-07-28 Ypuyu

文章目录

• • 1. 题目来源
  • 2. 题目解析

1. 题目来源

链接：166. 数独

前置题：

• [Hdfs] lc37. 解数独(dfs+经典) 在力扣中算难题了！

2. 题目解析

直接暴力按元素枚举会 TLE，但能过样例。

首先确定枚举顺序，枚举空格子的所有可填数字即可。

其次，针对常见的 dfs 四大优化，在本题中看看是如何应用的：

• 优化1：优化搜索顺序。每个空格子能填的数字个数是不同的，我们优先选择可选状态比较少的空格子来填，这样分支比较少，是个很重要的优化。
• 优化2：排除等效冗余。本题中无冗余，因为是按照空格子可选状态个数来搜索的，如果可选状态一样，按优先搜索位置靠前的空格子，顺序确定，不会冗余。
• 优化3：可行性剪枝。枚举行、列、九宫格中是否该数被使用。
• 优化4：最优性剪枝。本题只让输出一种可行方案即可，不需要进行最优性剪枝。

最后，考虑细节优化：

• 需要快速得到当前空格子所在的行、列、九宫格中哪些数字已经出现过，那些没出现过的数字就是当前格子所能填的所有状态。
• 可以使用一个 9 位二进制 01 串来表示行、列、九宫格每个数字的出现情况。其中 0 表示该数已经使用，1 表示该数未使用。
• 则当前空格子所能填的数，就将对应行、列、九宫格这三个二进制数 与 起来，其中二进制 1 的所在位置就表示该状态能填。
• 可以使用 lowbit() 操作 快速求得二进制表示中最后一位 1 的所在位置。

---

问题的思维难度不高，优化方式也比较平滑，但很综合，是个好题！

其中在代码实现上运用了很多小技巧，尤其是将状态初始化、空格填数、回溯这三个操作，抽象为一个函数，使得代码逻辑十分清晰。

---

时间复杂度：$O(指数级)$

空间复杂度：$O(n)$

---

数独优化：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 9, M = 1 << N;        // M=512

int ones[M], map[M];        // 快速统计每个状态有多少个 1，lowbit() 操作返回 2^a，求这个 a 等价于求 log
int row[N], col[N], cell[3][3];
char str[105];

int lowbit(int x) {
    return x & -x;
}

int get(int x, int y) {
    return row[x] & col[y] & cell[x / 3][y / 3];
}

// 0 代表该数已使用，1 代表该数未使用
void init() {
    for (int i = 0; i < N; i ++ ) row[i] = col[i] = (1 << N) - 1;

    for (int i = 0; i < 3; i ++ )
        for (int j = 0; j < 3; j ++ )
            cell[i][j] = (1 << N) - 1;
}

// 将 (x, y) 位置填入数字 t，is_set 用来标记是填数字还是恢复现场这两种操作
// 可用于初始化、填数字、回溯三种，用一个函数封装，属实流畅！
void draw(int x, int y, int t, bool is_set) {
    if (is_set) str[x * N + y] = t + '1';
    else str[x * N + y] = '.';

    // 注意 0 代表数已使用，1 代表该数未使用，状态得减....
    int v = 1 << t;
    if (!is_set) v = -v;

    row[x] -= v;
    col[y] -= v;
    cell[x / 3][y / 3] -= v;
}

bool dfs(int cnt) {
    if (!cnt) return true;

    int minv = 10;
    int x, y;
    for (int i = 0, k = 0; i < N; i ++ ) 
        for (int j = 0; j < N; j ++ , k ++ ) {
            if (str[k] == '.') {
                int state = get(i, j);
                if (ones[state] < minv) {
                    minv = ones[state];
                    x = i, y = j;
                }
            }
        }
    
    int state = get(x, y);
    for (int i = state; i; i -= lowbit(i)) {
        int t = map[lowbit(i)];                      // 找到最后一位 1 的位置
        draw(x, y, t, true);
        if (dfs(cnt - 1)) return true;
        draw(x, y, t, false);
    }

    return false;
}

int main() {
    for (int i = 0; i < N; i ++ ) map[1 << i] = i;
    for (int i = 0; i < 1 << N; i ++ ) {
        int t = i, cnt = 0;
        while (t) t -= lowbit(t), cnt ++ ;
        ones[i] = cnt;
    }

    while (cin >> str, str[0] != 'e') {
        init();     // 预处理行、列、九宫格

        int cnt = 0;      // 表示空格个数
        for (int i = 0, k = 0; i < N; i ++ ) 
            for (int j = 0; j < N; j ++ , k ++ ) 
                if (str[k] != '.') {
                    int t = str[k] - '1';       // 初始化数字情况
                    draw(i, j, t, true);
                } else {
                    cnt ++ ;
                }

        dfs(cnt);

        puts(str);
    }

    return 0;
}

---

dfs 按元素枚举朴素写法：

// 能过样例，但 TLE
#include <bits/stdc++.h>

using namespace std;

const int N = 10;

string g;
bool row[9][9], col[9][9], cell[3][3][9];      // 行、列、9宫格内的重复元素判断

bool dfs(int u) {
    if (u == g.size()) return true;

    if (g[u] != '.') return dfs(u + 1);
    
    int x = u / 9, y = u % 9;
    for (int i = 0; i < 9; i ++ ) {
        if (!row[x][i] && !col[y][i] && !cell[x / 3][y / 3][i]) {
            row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = true;
            g[u] = (char)(i + '1');
            // 找到之后不要回溯了...如果改成 void 则最终将回溯到初始状态相当于没改变
            if (dfs(u + 1)) return true;    
            row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = false;
            g[u] = '.';
        }
    }
    
    return false;
}

int main() {
    while (cin >> g, g != "end") {
        memset(row, 0, sizeof row);
        memset(col, 0, sizeof col);
        memset(cell, 0, sizeof cell);
        
        for (int i = 0; i < g.size(); i ++ ) {
            int x = i / 9, y = i % 9;
            if (g[i] != '.') 
                row[x][g[i] - '1'] = col[y][g[i] - '1'] = cell[x / 3][y / 3][g[i] - '1'] = true;
        }
        
        dfs(0);
        
        cout << g << endl;
    }
    
    return 0;
}