数独解题程序的JAVA实现

先上号称最难数独的解题结果图

简单:

其中使用int[9][9]的二维数组表示数独各位置的值和候选数：

16进制	2进制	意义
0x1	1	确定值1
0x2	10	确定值2
0x4	100	确定值3
0xD3	1101 0101	候选值1 3 5 7 8
0x1FF	1 1111 1111	候选值1 2 3 4 5 6 7 8 9

其中只使用了唯一候选数法和递归试填,虽然也写了其他解题技巧的实现（如隐性唯一候选数法、候选数区块删减法、候选数对删减法、隐性候选数对删减法等）,加入之后也可以将其变成一个解题演示器，但加入之后：1.时间效率上并不比现在的更高，2.并没有写完所有的已知解题技巧的实现，并且，即使写出了所有解题技巧的实现，递归试填仍然是解高级难题必须使用的方法。所以,最后也没加。

完整代码:

package test;

/**
 * @author l.wang(516066490@qq.com)
 */
public class Sudoku {
    /**
     * 号称最难数独( 空格分开的81个数字 0 表示待填,)
     */
    static String source = "8 0 0 0 0 0 0 0 0" +
                           "0 7 0 0 9 0 2 0 0" + 
                           "0 0 3 6 0 0 0 0 0" + 
                           "0 5 0 0 0 7 0 0 0" +
                           "0 0 0 0 4 5 7 0 0" + 
                           "0 0 0 1 0 0 0 3 0" + 
                           "0 0 1 0 0 0 0 6 8" +
                           "0 0 8 5 0 0 0 1 0" +
                           "0 9 0 0 0 0 4 0 0";
    static long start;
    static int i;

    public static void main(String[] args) {
        start = System.nanoTime();
        int[][] data = init(source);
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (data[i][j] == 0) {
                    data[i][j] = 0x1ff;
                }
            }
        }
        print(data);
        solve(data);
        System.out.println("总用时：" + (System.nanoTime() - start) / 1000000.0 + "ms");
    }

    private static void solve(int[][] data) {
        analyse(data);
        int result = check(data);
        if (result == 1) {
            int[] position = smallPosition(data);
            int pv = data[position[0]][position[1]];
            int pvcount = Integer.bitCount(pv);
            for (int i = 0; i < pvcount; i++) {
                int testV = 1 << ((int) (Math.log(Integer.highestOneBit(pv)) / Math.log(2)));
                pv ^= testV;
//               System.out.println("试填["+position[0]+","+position[1]+"]"+((int)
//               (Math.log(Integer.highestOneBit(testV)) / Math.log(2))+1));
                int[][] copy = copyData(data);
                copy[position[0]][position[1]] = testV;
                solve(copy);
            }
        } else if (result == 0) {
            System.out.println("------------------------------------第"+(++i)+"个答案---------------------"
                    + (System.nanoTime() - start) / 1000000.0 + "ms---");
            print(data);
        }
    }

    /**
     * 复制数独数组
     * @param data
     * @return
     */
    private static int[][] copyData(int[][] data) {
        int[][] copy = new int[9][9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                copy[i][j] = data[i][j];
            }
        }
        return copy;
    }

    /**
     * 找到候选数最少的位置开始尝试<br>
     * <b>****显著提升了效率*****<b>
     * @param data
     * @return int[2] 行列位置
     */
    public static int[] smallPosition(int[][] data) {
        int[] res = null;
        int smallCount = 10;
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                int bitcount = Integer.bitCount(data[i][j]);
                if (bitcount == 2) {
                    return new int[] { i, j };
                } else if (bitcount != 1) {
                    if (smallCount > bitcount) {
                        smallCount = bitcount;
                        res = new int[] { i, j };
                    }
                }
            }
        }
        return res;
    }

    /**
     * 检查结果
     * @param data
     * @return <b>0</b>   正确<br>
     *                  <b>1</b>    还有位置未填<br>
     *                  <b>-1</b>    错误<br>
     */
    private static int check(int[][] data) {
        for (int i = 0; i < 9; i++) {
            int row = 0;
            int col = 0;
            int block = 0;
            for (int j = 0; j < 9; j++) {
                if (Integer.bitCount(data[i][j]) > 1) {
                    return 1;
                }
                row |= data[i][j];
                col |= data[j][i];
            }

            for (int h = i / 3 * 3; h < i / 3 * 3 + 3; h++) {
                for (int l = i % 3 * 3; l < i % 3 * 3 + 3; l++) {
                    block |= data[h][l];
                }
            }
            if (row != 0x1ff || col != 0x1ff || block != 0x1ff) {
                return -1;
            }
        }
        return 0;
    }

    private static void analyse(int[][] data) {
        boolean changed = false;
        changed = reduce(data);
        //TODO 还可以加入其它删减候选数算法，将这变成一个解题演算器
        if (changed) {
            analyse(data);
        }
    }

    /**
     * 根据行列宫已有值进行简单的候选数删减
     * @param data
     * @return
     */
    private static boolean reduce(int[][] data) {
        boolean changed = false;
        for (int m = 0; m < 9; m++) {
            for (int n = 0; n < 9; n++) {
                if (Integer.bitCount(data[m][n]) != 1) {
                    if (setMaybe(data, m, n)) {
                        changed = true;
                    }
                }
            }
        }
        return changed;
    }

    /**
     * 设置m行n列位置的可能值
     * 
     * @param m
     *            行（0-8）
     * @param n
     *            列（0-8）
     * @return 是否减少了候选数
     */
    private static boolean setMaybe(int[][] data, int m, int n) {
        if (Integer.bitCount(data[m][n]) == 1) {
            return false;
        }
        int row = 0;// 行已确定值集合
        int col = 0;// 列已确定值集合
        int block = 0; // 宫格已确定值集合

        for (int i = 0; i < 9; i++) {
            if (Integer.bitCount(data[m][i]) == 1) {
                row += data[m][i];
            }
            if (Integer.bitCount(data[i][n]) == 1) {
                col += data[i][n];
            }
        }

        for (int i = m / 3 * 3; i < m / 3 * 3 + 3; i++) {
            for (int j = n / 3 * 3; j < n / 3 * 3 + 3; j++) {
                if (Integer.bitCount(data[i][j]) == 1) {
                    block += data[i][j];
                }
            }
        }

        int have = row | col | block;// 不可能的值
        int left = 0x1ff ^ have;// 候选数
        // System.out.println("["+m+","+n+"]"+Integer.toBinaryString(left));
        return tryReduce(data, m, n, left);
    }

    /**
     * 新的候选数与老的候选数比较，尝试减少候选数
     * 
     * @param data
     * @param m
     *            行（0-8）
     * @param n
     *            列（0-8）
     * @param v
     *            候选数，如0x1F9(二进制1 1111 1001)表示候选数为1 4 5 6 7 8 9
     * @return 是否改变了m行n列的候选数,<br/>
     *         <b>true</b> 减少了候选数<br/>
     *         <b>false</b> 没有减少
     */
    private static boolean tryReduce(int[][] data, int m, int n, int v) {
        int old = data[m][n];
        data[m][n] = old & v;
        return data[m][n] != old;
    }

    /**
     * 初始化数据
     * 
     * @param source
     *            空格分开的81个数字 0 表示待填
     * @return
     */
    private static int[][] init(String source) {
        source = source.replace(" ", "");
        int[][] data = new int[9][9];
        for (int i = 0; i < source.length(); i++) {
            //应该用source.charAt(i) - '0'
            int v = Integer.parseInt(source.charAt(i) + "");
            if (v != 0) {
                data[i / 9][i % 9] = 1 << (v - 1);
            }
        }
        return data;
    }

    /**
     * 打印数独
     * 
     * @param data
     */
    private static void print(int[][] data) {
        for (int m = 0; m < 9; m++) {
            for (int n = 0; n < 9; n++) {
                int v = getV9(data[m][n]);
                if (v != -1) {
                    System.out.print(v + " ");
                } else {
                    System.out.print("_ ");
                }
            }
            System.out.println();
        }
    }

    /**
     * 将使用1的位移表示的数字转换为整数;
     * 
     * @param v
     *            用1的位移表示的数值
     * @return
     */
    public static int getV9(int v) {
        // 使用switch与使用Math.log时间效率差不多
        switch (v) {
        case 1:
            return 1;
        case 2:
            return 2;
        case 4:
            return 3;
        case 8:
            return 4;
        case 16:
            return 5;
        case 32:
            return 6;
        case 64:
            return 7;
        case 128:
            return 8;
        case 256:
            return 9;
        default:
            break;
        }
        return -1;
    }

}