(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();
		}

	}
}