(Java)LeetCode-37. Sudoku Solver

Write a program to solve a Sudoku puzzle by filling the empty cells.

Empty cells are indicated by the character 

'.'

.

You may assume that there will be only one unique solution.



A sudoku puzzle...



...and its solution numbers marked in red.
这道题刚看题的时候我是懵逼的，这也太难了！果然是Hard模式！然后我看了下 Tags，显示backtracking，也就是回溯算法。然后去网上了解了一下回溯算法的思想，以及典型问题“八皇后问题”，不了解的可以看一下这个博客：http://blog.csdn.net/changyuanchn/article/details/17354461 
大致意思就是：回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。

既然是试探法，我的思路是这样的：

1. 找到下一个是 ' . ' 的点，看这个点所有可以取的值，若没有值，则说明前面出错了，要回溯（return false），若有值，则遍历所有可以取到的值赋值给改点

2. 对于每一个可以取到的值，将该店复制为该值之后（就是在这个时候矩阵状态发生了变化，可以递归了），找到下一个为 ' . '的点，若找不到，则已成功（return true），若找到了，则递归调用solveSudoku算法，跳转到第一步

3.若遍历完改点所有可以取到的值之后，发现都不能成功，则说明前面出错了，要回溯（return false）,回溯之前不能忘了恢复状态重新赋值为' . '

关于solveSudoku方法的返回值，我一开始考虑是void的，仿照八皇后问题，但是后来我发现八皇后问题要找到所有成立的可能性，而这一题里假设只要找到一种解法即可返回，所以我就用了Boolean返回类型。一旦成功立即结束。嘿嘿~居然成功了，这么复杂的代码可不常写啊，用掉了好多脑细胞~代码如下：

public class Solution {

public boolean solveSudoku(char[][] board) {
int nextNode = nextNode(board);
return solveSudoku(board, nextNode);
}

private boolean solveSudoku(char[][] board, int Node){
List<Integer> availNums = available(board, Node);
if(availNums.isEmpty()){
return false;
}
int line = Node / 10;
int col = Node % 10;
for(int node : availNums){
board[line][col] = (char)(node+'0');
int nextNode = nextNode(board);
if(nextNode == -1){
return true;
}else if(solveSudoku(board,nextNode)){
return true;
}
}
board[line][col] = '.';
return false;
}

private List<Integer> available(char[][] board,int Node){
boolean[] flags = new boolean[9];
int line = Node / 10;
int col = Node % 10;
for(int m = 0; m < 3; m++){
for(int n = 0; n < 3; n++){
char ch = board[m + line / 3 * 3][n + col / 3 * 3];
if(ch != '.'){
flags[Integer.parseInt(String.valueOf(ch))-1] = true;
}
}
}
for(char ch : board[line]){
if(ch != '.'){
flags[Integer.parseInt(String.valueOf(ch))-1] = true;
}
}
for(int i = 0; i < 9; i++){
char ch = board[i][col];
if(ch != '.'){
flags[Integer.parseInt(String.valueOf(ch))-1] = true;
}
}
List<Integer> result = new ArrayList<Integer>();
for(int i = 0; i < 9; i++){
if(flags[i] == false){
result.add(i+1);
}
}
return result;
}

private int nextNode(char[][] board){
for(int i = 0; i < board.length;i++){
for(int j = 0; j < board[i].length; j++){
if(board[i][j] == '.'){
return (i*10+j);
}
}
}
return -1;
}

public static void main(String[] args){
Solution sol = new Solution();
char[][] nums = {{'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'}};

//		List<Integer> list = sol.available(nums, 2);
//		for(int i : list){
//			System.out.println(i);
//		}
boolean result = sol.solveSudoku(nums);
System.out.println(result);
for(char[] ch : nums){
for(char c : ch){
System.out.print(String.valueOf(c)+" ");
}
System.out.println();
}

}
}