Java递归求数独的一个解

/**
 * Sudoku
 * @author Victor
 * @date 2013-7-10 上午8:47:44
 */
public class Sudoku {
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String input = "....3..9....2....1.5.9..............1.2.8.4.6.8.5...2..75......4.1..6..3.....4.6.";
        System.out.println(input);
        String out = new Sudoku().sudoku(input);
        if(out == null) {
            System.out.println("failed.");
        } else {
            System.out.println(out);
        }
    }

    private final static int MAX = 9;
    private int[][] input(String in) {
        final int[][] matrix = new int[MAX][MAX];
        for (int i = 0; i < MAX; i++) {
            for (int j = 0; j < MAX; j++) {
                char c = in.charAt(MAX * i + j);
                if(c == '.') {
                    matrix[i][j] = 0;
                } else {                    
                    matrix[i][j] = Integer.parseInt(String.valueOf(c));
                }                
            }
        }
        return matrix;
    }
    
    private String output(final int[][] matrix) {
        StringBuilder out = new StringBuilder();
        for (int i = 0; i < MAX; i++) {
            for (int j = 0; j < MAX; j++) {
                out.append(matrix[i][j]);        
            }
        }
        return out.toString();
    }

    private String sudoku(String input) {        
        // input matrix
        int[][] originalMatrix = input(input);
        int[][] detectMatrix = input(input);
        
        if(sudokuRecursive(originalMatrix, detectMatrix, 0)) {
            return output(detectMatrix);
        }
        
        return null;
    }
    
    /**
     * 递归求解
     * @author Victor
     * @date 2013-7-10 下午9:10:09
     * @param originalMatrix  原输入矩阵
     * @param detectMatrix   探测矩阵，存放每一个位置的探测结果
     * @param pos 当前探测的位置
     * @return boolean  是否成功
     */
    private boolean sudokuRecursive(int[][] originalMatrix, int[][] detectMatrix, int pos) {
        int x = pos / MAX;
        int y = pos % MAX;        
        if(pos == 81) {
            return true;
        }        
        if(originalMatrix[x][y] == 0) {
            for(int c = 1; c < MAX + 1; c++) {
                if(isAllowed(x, y, c, detectMatrix)) {
                    detectMatrix[x][y] = c;
                    if(sudokuRecursive(originalMatrix, detectMatrix, pos + 1))
                        return true;
                }
            }
            detectMatrix[x][y] = 0;
            return false;
        } else {
            detectMatrix[x][y] = originalMatrix[x][y];
            if(sudokuRecursive(originalMatrix, detectMatrix, pos + 1))
                return true;
        }
        return false;
     }
    
    /**
     * Check在(x,y)位置是否可以放置candidate
     * @author Victor
     * @date 2013-7-8 下午7:20:00
     * @param x x坐标 0,1,2....8
     * @param y y坐标 0,1,2....8
     * @param candidate 候选数字
     * @param matrix 输入矩阵
     * @return boolean 是否允许放置该数字
     */
    private static boolean isAllowed(final int x, final int y, final int candidate, final int[][] matrix) {
        return allowInRow(x, candidate, matrix) && allowInColumn(y, candidate, matrix) && allowInUnit(x, y, candidate, matrix);
    }

    private static boolean allowInRow(final int x, final int candidate, final int[][] matrix) {
        for(int y = 0; y < MAX; y++) {
            // y is immutable
            if(candidate == matrix[x][y])
                return false;
        }
        return true;
    }

    private static boolean allowInColumn(final int y, final int candidate, final int[][] matrix) {
        for(int x = 0; x < MAX; x++) {
            // x is immutable
            if(candidate == matrix[x][y])
                return false;
        }
        return true;
    }

    private static boolean allowInUnit(final int x, final int y, final int candidate, final int[][] matrix) {
        // 0,1,2 to 0; 3,4,5 to 1; 6,7,8 to 2
        int xScale = x / 3;
        int yScale = y / 3;
        for(int m = xScale * 3; m < (xScale + 1) * 3; m++) {
            for(int n = yScale * 3; n < (yScale + 1) * 3; n++) {
                // x is in [xScale * 3, (xScale + 1) * 3), y is in [yScale * 3, (yScale + 1) * 3)
                if(candidate == matrix[m][n])
                    return false;
            }
        }
        return true;
    }
}