【数据结构与算法】之深入解析“有效的数独”的求解思路与算法示例
【摘要】
一、题目要求
请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。...
一、题目要求
- 请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
-
- 数字 1-9 在每一行只能出现一次。
-
- 数字 1-9 在每一列只能出现一次。
-
- 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
- 注意：
-
- 一个有效的数独（部分已被填充）不一定是可解的。
-
- 只需要根据以上规则，验证已经填入的数字是否有效即可。
-
- 空白格用 ‘.’ 表示。
- 示例一：
输入：board =
[["5","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：true
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 示例 2：
输入：board =
[["8","3",".",".","7",".",".",".","."]
,["6",".",".","1","9","5",".",".","."]
,[".","9","8",".",".",".",".","6","."]
,["8",".",".",".","6",".",".",".","3"]
,["4",".",".","8",".","3",".",".","1"]
,["7",".",".",".","2",".",".",".","6"]
,[".","6",".",".",".",".","2","8","."]
,[".",".",".","4","1","9",".",".","5"]
,[".",".",".",".","8",".",".","7","9"]]
输出：false
解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与示例 1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 提示：
-
- board.length == 9；
-
- board[i].length == 9；
-
- board[i][j] 是一位数字（1-9）或者 ‘.’。
二、求解算法
① 哈希表
- 由于只要判断是否为有效的数独，所以只需要对 board 中出现的数进行判断，如果 board 中有数违反了数独的规则，返回 false，否则返回 true。
- 直观上，我们很容易想到使用 哈希表 来记录某行/某列/某个小方块出现过哪些数字，来帮助我们判断是否符合「有效数独」的定义。
- 这道题唯一的难点可能是在于如何确定某个数落在哪个小方块中，我们可以去小方块进行编号：
- 然后推导出小方块编号和行列的关系为： idx=⌊i/3⌋∗3+⌊j/3⌋。
- Java 示例：
class Solution {
public boolean isValidSudoku(char[][] board) {
Map<Integer, Set<Integer>> row = new HashMap<>(), col = new HashMap<>(), area = new HashMap<>();
for (int i = 0; i < 9; i++) {
row.put(i, new HashSet<>());
col.put(i, new HashSet<>());
area.put(i, new HashSet<>());
}
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];
if (c == '.') continue;
int u = c - '0';
int idx = i / 3 * 3 + j / 3;
if (row.get(i).contains(u) || col.get(j).contains(u) || area.get(idx).contains(u)) return false;
row.get(i).add(u);
col.get(j).add(u);
area.get(idx).add(u);
}
}
return true;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
② 数组
- 大多数的哈希表计数问题，都能转换为使用数组解决。
- 虽然时间复杂度一样，但哈希表的更新和查询复杂度为均摊 O(1)，而定长数组的的更新和查询复杂度则是严格 O(1)。因此从执行效率上来说，数组要比哈希表快上不少。
- Java 示例：
class Solution {
public boolean isValidSudoku(char[][] board) {
boolean[][] row = new boolean[10][10], col = new boolean[10][10], area = new boolean[10][10];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
int c = board[i][j];
if (c == '.') continue;
int u = c - '0';
int idx = i / 3 * 3 + j / 3;
if (row[i][u] || col[j][u] || area[idx][u]) return false;
row[i][u] = col[j][u] = area[idx][u] = true;
}
}
return true;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
③ 位运算
- 更进一步，可以使用一个 int 来记录 某行/某列/某个小方块 的数值填入情况：使用从低位开始的 [1,9] 位来记录该数值是否已被填入。
- 例如 (…111000111.)2 代表数值 [1,3] 和 [7,9] 均被填入。
- Java 示例：
class Solution {
public boolean isValidSudoku(char[][] board) {
int[] row = new int[10], col = new int[10], area = new int[10];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];
if (c == '.') continue;
int u = c - '0';
int idx = i / 3 * 3 + j / 3;
if ((((row[i] >> u) & 1) == 1) || (((col[j] >> u) & 1) == 1) || (((area[idx] >> u) & 1) == 1)) return false;
row[i] |= (1 << u);
col[j] |= (1 << u);
area[idx] |= (1 << u);
}
}
return true;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
④ 一次遍历（LeetCode 官方解法）
- 有效的数独满足以下三个条件：
-
- 同一个数字在每一行只能出现一次；
-
- 同一个数字在每一列只能出现一次；
-
- 同一个数字在每一个小九宫格只能出现一次。
- 可以使用哈希表记录每一行、每一列和每一个小九宫格中，每个数字出现的次数。只需要遍历数独一次，在遍历的过程中更新哈希表中的计数，并判断是否满足有效的数独的条件即可。
- 对于数独的第 i 行第 j 列的单元格，其中 0≤i,j<9，该单元格所在的行下标和列下标分别为 i 和 j，该单元格所在的小九宫格的行数和列数分别为 ⌊i/3⌋ 和 ⌊j/3⌋，其中 0≤⌊i/3⌋，⌊i/3⌋ < 3。
- 由于数独中的数字范围是 1 到 9，因此可以使用数组代替哈希表进行计数。具体做法是，创建二维数组 rows 和 columns 分别记录数独的每一行和每一列中的每个数字的出现次数，其中 rows[i][index]、columns[j][index] 和 subboxes[⌊i/3⌋][⌊j/3⌋][index] 分别表示数独的第 i 行第 j 列的单元格所在的行、列和小九宫格中，数字 index+1 出现的次数，其中 0≤index<9，对应的数字 index+1 满足 1≤index+1≤9。
- 如果 board[i][j] 填入了数字 n，则将 rows[i][n−1]、columns[j][n−1] 和 subboxes[⌊i/3⌋][⌊j/3⌋][n−1] 各加 1。如果更新后的计数大于 1，则不符合有效的数独的条件，返回 false。
- 如果遍历结束之后没有出现计数大于 1 的情况，则符合有效的数独的条件，返回 true。
- Java 示例：
class Solution {
public boolean isValidSudoku(char[][] board) {
int[][] rows = new int[9][9];
int[][] columns = new int[9][9];
int[][][] subboxes = new int[3][3][9];
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];
if (c != '.') {
int index = c - '0' - 1;
rows[i][index]++;
columns[j][index]++;
subboxes[i / 3][j / 3][index]++;
if (rows[i][index] > 1 || columns[j][index] > 1 || subboxes[i / 3][j / 3][index] > 1) {
return false;
}
}
}
}
return true;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- C++ 示例：
class Solution {
public:
bool isValidSudoku(vector<vector<char>>& board) {
int rows[9][9];
int columns[9][9];
int subboxes[3][3][9];
memset(rows,0,sizeof(rows));
memset(columns,0,sizeof(columns));
memset(subboxes,0,sizeof(subboxes));
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
char c = board[i][j];
if (c != '.') {
int index = c - '0' - 1;
rows[i][index]++;
columns[j][index]++;
subboxes[i / 3][j / 3][index]++;
if (rows[i][index] > 1 || columns[j][index] > 1 || subboxes[i / 3][j / 3][index] > 1) {
return false;
}
}
}
}
return true;
}
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
文章来源: blog.csdn.net，作者：Serendipity·y，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/Forever_wj/article/details/122731043
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）