[LeetCode 37] 解数独

题目描述

Note:

给定的数独序列只包含数字 1-9 和字符 ‘.’ 。
你可以假设给定的数独只有唯一解。
给定数独永远是 9x9 形式的。

题目分析

前面的分析和LeetCode 36的一摸一样，不过是先遍历一遍数独，把已经填好的数字保存在那三个数组中，如果不做36直接上手37还是挺难的。保存完之后就是添加了，再遍历一次获取空的项，填入1-9中的一个数，这个数的前提就是不能重复啦。如果全部填入成功的话，那返回true，如果不行，那就删掉重新再填其他的。

源码

class Solution {
public void solveSudoku(char[][] board) {
    boolean[][] row = new boolean[9][10];
    boolean[][] col = new boolean[9][10];
    boolean[][] block = new boolean[9][10];

    for (int i=0;i<9;i++) {
        for (int j = 0; j < 9; j++) {
            if (board[i][j] != '.') {
                int num = board[i][j] - '0';
                row[i][num] = true;
                col[j][num] = true;
                block[i / 3 * 3 + j / 3][num] = true;
            }
        }
    }
    //开始回溯，添加数字，如果不符合那么回到添加的第一步重新添加
    dfs(board, row, col, block, 0, 0);
}

private boolean dfs(char[][] board, boolean[][] row, boolean[][] col, boolean[][] block, int i, int j) {
    while (board[i][j] != '.') {
        if (++j >= 9) {
            i++;
            j = 0;
        }
        if (i >= 9) {
            return true;
            //遍历完全部都填满了
        }
    }
    //找到非空的地址
    for (int num = 1; num <= 9; num++) {
        int blockIndex = i / 3 * 3 + j / 3;
        if (!row[i][num] && !col[j][num] && !block[blockIndex][num]) {
            board[i][j] = (char) ('0' + num);
            row[i][num] = true;
            col[j][num] = true;
            block[blockIndex][num] = true;
            if (dfs(board, row, col, block, i, j)) {
                return true;
                //递归，如果填进去完全能符合数独了
            } else {
                row[i][num] = false;
                col[j][num] = false;
                block[blockIndex][num] = false;
                board[i][j] = '.';
                //回溯
            }
        }
    }
    return false;
}

}

难点

对于我来说，难点主要是一个。就是如何去填数进去保证填完之后这个数独一定就是成立的。我第一次填进去，填这一行看看能不能组成，不行的话我就必须要回去把那个数删了再填其他的数试试。也就是说我在以这个位置为一个三角形的顶端，往下去试，不成功就换个顶继续试，直到成功为止，这个思想就是很典型的回溯了。

分析

时间复杂度为O(n^2)

改进

这道题用三个数组还是感觉有点累赘，那有没有什么办法用其他的数据结构呢？其实可以， 只要找到了行列的索引值，那么其实就可以把数组给省了。

改进代码

public void solveSudoku(char[][] board) {
	if (board == null || board.length == 0)
		return;
	dfs(board);
}
// 也是按照行进行放置，只不过n后问题每行只放一个Q，不重复放置，是一层循环
// 而此题需要放置多个数字，还不能重复,所以是一个三层循环
private boolean dfs(char[][] board) {
	for (int i = 0; i < board.length; i++) {
		for (int j = 0; j < board[0].length; j++) {
			if (board[i][j] == '.') {
				for (char num = '1'; num <= '9'; num++) {
					// 尝试
					if (validate(board, i, j, num)) {
						board[i][j] = num;
						if (dfs(board))
							return true;
						else// 回溯
							board[i][j] = '.';
					}
				}
				// 如果对一个格子尝试从0~9都不行，
				// 那么说明整个sudoku无解，返回false
				return false;
			}
		}
	}

	// 对整个棋盘所有'.'都填完了，那么就可以返回true了。
	return true;
}

// 通常验证函数需要单独解耦合
private boolean validate(char[][] board, 
		int i, int j, char c) {
	// check column（列）
	for (int row = 0; row < 9; row++)
		if (board[row][j] == c)
			return false;

	// check row（行）
	for (int col = 0; col < 9; col++)
		if (board[i][col] == c)
			return false;

	// check cube(小九宫格)
	int rIdx = i / 3 * 3;
	int cIdx = j / 3 * 3;
	for (int row = rIdx; row < rIdx + 3; row++)
		for (int col = cIdx; col < cIdx + 3; col++)
			if (board[row][col] == c)
				return false;

	return true;
}

小结

做数独题时，最好做的就是分别保存行列九宫格三个数组，当三个都成立时，那么这个数独也就成立了。填数据一次就填对的几率太小太小了，那么就需要不断试，这时候就要想到组合问题，那么回溯就是一个很经典的办法。

[1]https://leetcode-cn.com/problems/sudoku-solver/
[2]https://blog.csdn.net/mine_song/article/details/70209738