leetcode -- 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...

 思路：回溯(Backtracking)，回溯题练得太少，知道应该用回溯写，但不知如何下笔。。。。。

下面代码是参考网上博客写的，回溯题有如下几点需要注意：

1. 应当有个独立的isValid判断函数

2. 递归求解，递归函数应当有返回值来判断当前解是否正确

3. 对当前位置先取一个值，然后判断是否正确，如是，则继续下面的递归；否则，清空刚才赋的值，进行下一次尝试

这里isValid方法我原来是使用的Valid Sudoku的解，提交时发现会超时，参考了下别人的实现发现：有许多的判断是多余的，如：

当在[x][y]出取一个值时，只需要判断x行，y列，以及x，y所处的9宫格中是否valid即可，这样会减少很多无用的判断，代码中注释部分是

原来的实现。比较下可以提高8倍左右。

public class Solution {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        char[][] board = new char[][] { "..9748...".toCharArray(),
                "7........".toCharArray(), ".2.1.9...".toCharArray(),
                "..7...24.".toCharArray(), ".64.1.59.".toCharArray(),
                ".98...3..".toCharArray(), "...8.3.2.".toCharArray(),
                "........6".toCharArray(), "...2759..".toCharArray() };
        long start = System.nanoTime();
        solveSudokuRecursive(board);
        long end = System.nanoTime();
        System.out.println((end - start) * 1e-6);
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print(board[i][j]);
                System.out.print(' ');
            }
            System.out.println();
        }

    }

    public void solveSudoku(char[][] board) {
        // Start typing your Java solution below
        // DO NOT write main() function
        solveSudokuRecursive(board);
    }

    public static boolean solveSudokuRecursive(char[][] board) {
        int[] pairs = getFirstEmpty(board);
        if (pairs[0] == -1 && pairs[1] == -1)
            return true;
        for (int i = 1; i <= 9; i++) {
            board[pairs[0]][pairs[1]] = (char) (i + '0');
            if (isValid(board, pairs[0], pairs[1])
                    && solveSudokuRecursive(board)) {
                return true;
            }
            // backtrack
            board[pairs[0]][pairs[1]] = '.';
        }
        return false;
    }

    public static int[] getFirstEmpty(char[][] board) {
        int[] pairs = null;
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] == '.') {
                    pairs = new int[] { i, j };
                    return pairs;
                }
            }
        }
        pairs = new int[] { -1, -1 };
        return pairs;
    }

    /**
     * reduce some unnecessary compare by transport two parameters
     * 
     * @param board
     * @param x
     * @param y
     * @return
     */
    public static boolean isValid(char[][] board, int x, int y) {
        // Set<Character> row = new HashSet<Character>();
        // Set<Character> col = new HashSet<Character>();

        for (int i = 0; i < 9; i++) {
            if (i != y && board[x][i] == board[x][y])
                return false;

            if (i != x && board[i][y] == board[x][y])
                return false;
        }

//        for (int i = 0; i < 9; i++) {
//            row.clear();
//            col.clear();
//            for (int j = 0; j < 9; j++) {
//                if (board[i][j] != '.') {
//                    if (row.contains(board[i][j]))
//                        return false;
//                    else {
//                        row.add(board[i][j]);
//                    }
//                }
//
//                if (board[j][i] != '.') {
//                    if (col.contains(board[j][i]))
//                        return false;
//                    else
//                        col.add(board[j][i]);
//                }
//
//            }
//        }
        int xIdx = (x / 3) * 3;
        int yIdx = (y / 3) * 3;
        for (int m = 0; m < 3; m++) {
            for (int n = 0; n < 3; n++) {
                if(m + xIdx != x && n + yIdx != y && board[m + xIdx][n + yIdx] == board[x][y])// 判断9宫格中是否存在board[x][y]
                    return false;
            }
        }

//        Set<Character> container = new HashSet<Character>();
//        for (int i = 0; i < 9; i += 3) {
//            for (int j = 0; j < 9; j += 3) {
//                for (int m = 0; m < 3; m++) {
//                    for (int n = 0; n < 3; n++) {
//                        if (board[m + i][n + j] == '.') {
//                            continue;
//                        }
//                        if (container.contains(board[m + i][n + j]))
//                            return false;
//                        else {
//                            container.add(board[m + i][n + j]);
//                        }
//                    }
//
//                }
//                container.clear();
//            }
//        }
        return true;
    }
}

 ref:http://blog.csdn.net/zxzxy1988/article/details/8586289