Java回溯算法解数独问题

    下面来详细讲一下如何用回溯算法来解数独问题。

    下图是一个数独题，也是号称世界上最难的数独。当然了，对于计算机程序来说，只要算法是对的，难不难就不知道了，反正计算机又不累。回溯算法基本上就是穷举，解这种数独类的问题逻辑比较简单。

不管算法懂不懂，先把类建出来，变量定义好，那放大学试卷上就是可以拿两分了。

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.     public Sudoku(int[][] matrix) {  
9.         this.matrix = matrix;  
10.     }  
11.   
12.     public static void main(String[] args) {  
13.         // 号称世界上最难数独  
14.         int[][] sudoku = {  
15.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
16.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
17.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
18.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
19.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
20.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
21.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
22.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
23.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
24.         Sudoku s = new Sudoku(sudoku);  
25.         s.backTrace(0, 0);  
26.     }  
27.   
28.     /** 
29.      * 数独算法 
30.      * @param i 
31.      * 行号 
32.      * @param j 
33.      * 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.   
37.     }  
38. }  

    用一个二维数组来存储这个矩阵，然后定义一个方法来计算。方法里有两个属性——行号和列号。

    我们的原理就是从第0行0列开始，依次往里面填入1-9之间的数字，然后判断填入的这个数字是否能放进去（该行该列和它所在的小九宫格是否有重复数字）。如果能放进去，那么就继续用1-9去试该行的下一列。一直到该行的最后一列，然后换行继续重复上面的步骤（也就是执行backTrace方法）。一直执行到最后一个空格，也就是i=8,j=8的时候，且最后这个空格所放的值也完全符合规则，那么此时就算完成，不用再继续调用backTrace方法了，输出正确解即可。

   

所以回溯法样子看起来是这样的。给第一个空格填1-9中任何一个，开始判断，如果OK，然后进入下一层，如果不OK，就断掉了。下一层还是从1-9开始试，然后OK，不OK……当最终目标达到时，空格已填满又满足条件，那么中断该分支，输出结果。

    继续我们的程序。

    由于有些位置已经有数字了，所以我们需要判断，如果该坑已经有人蹲了，那么就把列号j加1，进入下一列。如果到第8列了，就换行。

    修改程序如下：

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.   
9.     public Sudoku(int[][] matrix) {  
10.         this.matrix = matrix;  
11.     }  
12.   
13.     public static void main(String[] args) {  
14.         // 号称世界上最难数独  
15.         int[][] sudoku = {  
16.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
17.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
18.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
19.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
20.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
21.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
22.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
23.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
24.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
25.         Sudoku s = new Sudoku(sudoku);  
26.         s.backTrace(0, 0);  
27.     }  
28.   
29.     /** 
30.      * 数独算法 
31.      * 
32.      * @param i 行号 
33.      * @param j 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.         //如果i行j列是空格，那么才进入给空格填值的逻辑  
37.         if (matrix[i][j] == 0) {  
38.             for (int k = 1; k <= 9; k++) {  
39.                 //判断给i行j列放1-9中的任意一个数是否能满足规则  
40.                 if (check(i, j, k)) {  
41.                     //将该值赋给该空格，然后进入下一个空格  
42.                     matrix[i][j] = k;  
43.                     backTrace(i, j + 1);  
44.                 }  
45.             }  
46.         } else {  
47.             //如果该位置已经有值了，就进入下一个空格进行计算  
48.             backTrace(i, j + 1);  
49.         }  
50.     }  
51.   
52.     /** 
53.      * 判断给某行某列赋值是否符合规则 
54.      * 
55.      * @param row    被赋值的行号 
56.      * @param line   被赋值的列号 
57.      * @param number 赋的值 
58.      * @return 
59.      */  
60.     private boolean check(int row, int line, int number) {  
61.         //判断该行该列是否有重复数字  
62.         for (int i = 0; i < 9; i++) {  
63.             if (matrix[row][i] == number || matrix[i][line] == number) {  
64.                 return false;  
65.             }  
66.         }  
67.         //判断小九宫格是否有重复  
68.         int tempRow = row / 3;  
69.         int tempLine = line / 3;  
70.         for (int i = 0; i < 3; i++) {  
71.             for (int j = 0; j < 3; j++) {  
72.                 if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {  
73.                     return false;  
74.                 }  
75.             }  
76.         }  
77.   
78.         return true;  
79.     }  
80. }  

此时已经写好了判断某行某列赋某个值是否ok的方法，通过该方法就能校验出数字是否能放到该位置。

还缺少的是边界值的判断，就是当已经到最后一列了，还没到最后一行时，需要对行号加1，然后恢复列号为0。

修改一下backTrace方法，增加边界值判断。

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.   
9.     public Sudoku(int[][] matrix) {  
10.         this.matrix = matrix;  
11.     }  
12.   
13.     public static void main(String[] args) {  
14.         // 号称世界上最难数独  
15.         int[][] sudoku = {  
16.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
17.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
18.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
19.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
20.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
21.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
22.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
23.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
24.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
25.         Sudoku s = new Sudoku(sudoku);  
26.         s.backTrace(0, 0);  
27.     }  
28.   
29.     /** 
30.      * 数独算法 
31.      * 
32.      * @param i 行号 
33.      * @param j 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.         if (i == 8 && j == 9) {  
37.             //已经成功了，打印数组即可  
38.             System.out.println("获取正确解");  
39.             printArray();  
40.             return;  
41.         }  
42.   
43.         //已经到了列末尾了，还没到行尾，就换行  
44.         if (j == 9) {  
45.             i++;  
46.             j = 0;  
47.         }  
48.   
49.         //如果i行j列是空格，那么才进入给空格填值的逻辑  
50.         if (matrix[i][j] == 0) {  
51.             for (int k = 1; k <= 9; k++) {  
52.                 //判断给i行j列放1-9中的任意一个数是否能满足规则  
53.                 if (check(i, j, k)) {  
54.                     //将该值赋给该空格，然后进入下一个空格  
55.                     matrix[i][j] = k;  
56.                     backTrace(i, j + 1);  
57.                 }  
58.             }  
59.         } else {  
60.             //如果该位置已经有值了，就进入下一个空格进行计算  
61.             backTrace(i, j + 1);  
62.         }  
63.     }  
64.   
65.     /** 
66.      * 判断给某行某列赋值是否符合规则 
67.      * 
68.      * @param row    被赋值的行号 
69.      * @param line   被赋值的列号 
70.      * @param number 赋的值 
71.      * @return 
72.      */  
73.     private boolean check(int row, int line, int number) {  
74.         //判断该行该列是否有重复数字  
75.         for (int i = 0; i < 9; i++) {  
76.             if (matrix[row][i] == number || matrix[i][line] == number) {  
77.                 return false;  
78.             }  
79.         }  
80.         //判断小九宫格是否有重复  
81.         int tempRow = row / 3;  
82.         int tempLine = line / 3;  
83.         for (int i = 0; i < 3; i++) {  
84.             for (int j = 0; j < 3; j++) {  
85.                 if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {  
86.                     return false;  
87.                 }  
88.             }  
89.         }  
90.   
91.         return true;  
92.     }  
93.   
94.     /** 
95.      * 打印矩阵 
96.      */  
97.     public void printArray() {  
98.         for (int i = 0; i < 9; i++) {  
99.             for (int j = 0; j < 9; j++) {  
100.                 System.out.print(matrix[i][j] + " ");  
101.             }  
102.             System.out.println();  
103.         }  
104.         System.out.println();  
105.     }  
106. }  

    可以看到，判断成功的标志是行号为8，且列号为9时，认为找到了正确解。为什么是9呢，因为在check(i,j,k)那一步，通过了的话，将值K赋给最后一个空格，此时并没有中断程序，而且进入了下一层循环backTrace（i，j + 1），所以i为8j为9时才是终解。程序到这里，运行一下看看，发现并没有任何输出值，并没有找到正确解，why？

    下面要讲的就是该程序最关键的地方，也是比较难以理解的地方，就是对根节点的初始化。回溯算法讲究的是一条道走到黑，不撞南墙不回头，并且把所有的道都走完。

    我们把问题简单化，譬如一共只有两个空格，只能放0和1，正确答案是00和11.我们给第一个空格放了0，此时我们不知道是否放了0之后，后面是否能完全正确的走完全程。就像走迷宫一样，你选择了第一个岔道，此时有可能第一个岔道就是错的，后面无论怎么走都对了不了，也有可能有多条道可以走。那么我们的做法是先第一步放0，发现没问题（符合只能放0和1的规则），然后走第二步，第二步如果走对了，那就直接走出去了，获得了一次正确的解（00）。如果第二步是个死胡同（01），那就要回头了，就是要回到原点，把第一步初始化一下，然后第一步走1，然后再继续后面的步骤。所以无论怎么样，你都需要在第二步走完之后，把第一步走的值给清掉，回归到原点。这样才能找到所有的正确路线。

    问题放大一下，有N步（N未知），第一步有1-9共9种情况，第一步放了1，后面还有未知的步，那无论后面成功与否，你肯定都要去试第一步放2-9之间的数字。

    看第51行for循环那里，第一次将数字1赋给第一个空格。然后判断是否OK，如果OK了，就进入第二个空格去了，后面具体走多少步我们就不管了，我们只需要在后面的走完之后，初始化第一个空格就行了。那要是不OK呢，不OK当然就不用管他了，这一层走完就没下文了，等于该分支就断了。所以我们要在第55行后面加一句初始化的操作matrix[i][j]=0.

   完整代码如下：

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.   
9.     public Sudoku(int[][] matrix) {  
10.         this.matrix = matrix;  
11.     }  
12.   
13.     public static void main(String[] args) {  
14.         // 号称世界上最难数独  
15.         int[][] sudoku = {  
16.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
17.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
18.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
19.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
20.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
21.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
22.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
23.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
24.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
25.         Sudoku s = new Sudoku(sudoku);  
26.         s.backTrace(0, 0);  
27.     }  
28.   
29.     /** 
30.      * 数独算法 
31.      * 
32.      * @param i 行号 
33.      * @param j 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.         if (i == 8 && j == 9) {  
37.             //已经成功了，打印数组即可  
38.             System.out.println("获取正确解");  
39.             printArray();  
40.             return;  
41.         }  
42.   
43.         //已经到了列末尾了，还没到行尾，就换行  
44.         if (j == 9) {  
45.             i++;  
46.             j = 0;  
47.         }  
48.   
49.         //如果i行j列是空格，那么才进入给空格填值的逻辑  
50.         if (matrix[i][j] == 0) {  
51.             for (int k = 1; k <= 9; k++) {  
52.                 //判断给i行j列放1-9中的任意一个数是否能满足规则  
53.                 if (check(i, j, k)) {  
54.                     //将该值赋给该空格，然后进入下一个空格  
55.                     matrix[i][j] = k;  
56.                     backTrace(i, j + 1);  
57.                     //初始化该空格  
58.                     matrix[i][j] = 0;  
59.                 }  
60.             }  
61.         } else {  
62.             //如果该位置已经有值了，就进入下一个空格进行计算  
63.             backTrace(i, j + 1);  
64.         }  
65.     }  
66.   
67.     /** 
68.      * 判断给某行某列赋值是否符合规则 
69.      * 
70.      * @param row    被赋值的行号 
71.      * @param line   被赋值的列号 
72.      * @param number 赋的值 
73.      * @return 
74.      */  
75.     private boolean check(int row, int line, int number) {  
76.         //判断该行该列是否有重复数字  
77.         for (int i = 0; i < 9; i++) {  
78.             if (matrix[row][i] == number || matrix[i][line] == number) {  
79.                 return false;  
80.             }  
81.         }  
82.         //判断小九宫格是否有重复  
83.         int tempRow = row / 3;  
84.         int tempLine = line / 3;  
85.         for (int i = 0; i < 3; i++) {  
86.             for (int j = 0; j < 3; j++) {  
87.                 if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {  
88.                     return false;  
89.                 }  
90.             }  
91.         }  
92.   
93.         return true;  
94.     }  
95.   
96.     /** 
97.      * 打印矩阵 
98.      */  
99.     public void printArray() {  
100.         for (int i = 0; i < 9; i++) {  
101.             for (int j = 0; j < 9; j++) {  
102.                 System.out.print(matrix[i][j] + " ");  
103.             }  
104.             System.out.println();  
105.         }  
106.         System.out.println();  
107.     }  
108. }  

    下面来详细讲一下如何用回溯算法来解数独问题。

    下图是一个数独题，也是号称世界上最难的数独。当然了，对于计算机程序来说，只要算法是对的，难不难就不知道了，反正计算机又不累。回溯算法基本上就是穷举，解这种数独类的问题逻辑比较简单。

不管算法懂不懂，先把类建出来，变量定义好，那放大学试卷上就是可以拿两分了。

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.     public Sudoku(int[][] matrix) {  
9.         this.matrix = matrix;  
10.     }  
11.   
12.     public static void main(String[] args) {  
13.         // 号称世界上最难数独  
14.         int[][] sudoku = {  
15.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
16.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
17.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
18.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
19.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
20.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
21.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
22.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
23.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
24.         Sudoku s = new Sudoku(sudoku);  
25.         s.backTrace(0, 0);  
26.     }  
27.   
28.     /** 
29.      * 数独算法 
30.      * @param i 
31.      * 行号 
32.      * @param j 
33.      * 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.   
37.     }  
38. }  

    用一个二维数组来存储这个矩阵，然后定义一个方法来计算。方法里有两个属性——行号和列号。

    我们的原理就是从第0行0列开始，依次往里面填入1-9之间的数字，然后判断填入的这个数字是否能放进去（该行该列和它所在的小九宫格是否有重复数字）。如果能放进去，那么就继续用1-9去试该行的下一列。一直到该行的最后一列，然后换行继续重复上面的步骤（也就是执行backTrace方法）。一直执行到最后一个空格，也就是i=8,j=8的时候，且最后这个空格所放的值也完全符合规则，那么此时就算完成，不用再继续调用backTrace方法了，输出正确解即可。

   

所以回溯法样子看起来是这样的。给第一个空格填1-9中任何一个，开始判断，如果OK，然后进入下一层，如果不OK，就断掉了。下一层还是从1-9开始试，然后OK，不OK……当最终目标达到时，空格已填满又满足条件，那么中断该分支，输出结果。

    继续我们的程序。

    由于有些位置已经有数字了，所以我们需要判断，如果该坑已经有人蹲了，那么就把列号j加1，进入下一列。如果到第8列了，就换行。

    修改程序如下：

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.   
9.     public Sudoku(int[][] matrix) {  
10.         this.matrix = matrix;  
11.     }  
12.   
13.     public static void main(String[] args) {  
14.         // 号称世界上最难数独  
15.         int[][] sudoku = {  
16.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
17.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
18.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
19.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
20.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
21.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
22.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
23.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
24.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
25.         Sudoku s = new Sudoku(sudoku);  
26.         s.backTrace(0, 0);  
27.     }  
28.   
29.     /** 
30.      * 数独算法 
31.      * 
32.      * @param i 行号 
33.      * @param j 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.         //如果i行j列是空格，那么才进入给空格填值的逻辑  
37.         if (matrix[i][j] == 0) {  
38.             for (int k = 1; k <= 9; k++) {  
39.                 //判断给i行j列放1-9中的任意一个数是否能满足规则  
40.                 if (check(i, j, k)) {  
41.                     //将该值赋给该空格，然后进入下一个空格  
42.                     matrix[i][j] = k;  
43.                     backTrace(i, j + 1);  
44.                 }  
45.             }  
46.         } else {  
47.             //如果该位置已经有值了，就进入下一个空格进行计算  
48.             backTrace(i, j + 1);  
49.         }  
50.     }  
51.   
52.     /** 
53.      * 判断给某行某列赋值是否符合规则 
54.      * 
55.      * @param row    被赋值的行号 
56.      * @param line   被赋值的列号 
57.      * @param number 赋的值 
58.      * @return 
59.      */  
60.     private boolean check(int row, int line, int number) {  
61.         //判断该行该列是否有重复数字  
62.         for (int i = 0; i < 9; i++) {  
63.             if (matrix[row][i] == number || matrix[i][line] == number) {  
64.                 return false;  
65.             }  
66.         }  
67.         //判断小九宫格是否有重复  
68.         int tempRow = row / 3;  
69.         int tempLine = line / 3;  
70.         for (int i = 0; i < 3; i++) {  
71.             for (int j = 0; j < 3; j++) {  
72.                 if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {  
73.                     return false;  
74.                 }  
75.             }  
76.         }  
77.   
78.         return true;  
79.     }  
80. }  

此时已经写好了判断某行某列赋某个值是否ok的方法，通过该方法就能校验出数字是否能放到该位置。

还缺少的是边界值的判断，就是当已经到最后一列了，还没到最后一行时，需要对行号加1，然后恢复列号为0。

修改一下backTrace方法，增加边界值判断。

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.   
9.     public Sudoku(int[][] matrix) {  
10.         this.matrix = matrix;  
11.     }  
12.   
13.     public static void main(String[] args) {  
14.         // 号称世界上最难数独  
15.         int[][] sudoku = {  
16.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
17.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
18.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
19.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
20.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
21.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
22.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
23.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
24.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
25.         Sudoku s = new Sudoku(sudoku);  
26.         s.backTrace(0, 0);  
27.     }  
28.   
29.     /** 
30.      * 数独算法 
31.      * 
32.      * @param i 行号 
33.      * @param j 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.         if (i == 8 && j == 9) {  
37.             //已经成功了，打印数组即可  
38.             System.out.println("获取正确解");  
39.             printArray();  
40.             return;  
41.         }  
42.   
43.         //已经到了列末尾了，还没到行尾，就换行  
44.         if (j == 9) {  
45.             i++;  
46.             j = 0;  
47.         }  
48.   
49.         //如果i行j列是空格，那么才进入给空格填值的逻辑  
50.         if (matrix[i][j] == 0) {  
51.             for (int k = 1; k <= 9; k++) {  
52.                 //判断给i行j列放1-9中的任意一个数是否能满足规则  
53.                 if (check(i, j, k)) {  
54.                     //将该值赋给该空格，然后进入下一个空格  
55.                     matrix[i][j] = k;  
56.                     backTrace(i, j + 1);  
57.                 }  
58.             }  
59.         } else {  
60.             //如果该位置已经有值了，就进入下一个空格进行计算  
61.             backTrace(i, j + 1);  
62.         }  
63.     }  
64.   
65.     /** 
66.      * 判断给某行某列赋值是否符合规则 
67.      * 
68.      * @param row    被赋值的行号 
69.      * @param line   被赋值的列号 
70.      * @param number 赋的值 
71.      * @return 
72.      */  
73.     private boolean check(int row, int line, int number) {  
74.         //判断该行该列是否有重复数字  
75.         for (int i = 0; i < 9; i++) {  
76.             if (matrix[row][i] == number || matrix[i][line] == number) {  
77.                 return false;  
78.             }  
79.         }  
80.         //判断小九宫格是否有重复  
81.         int tempRow = row / 3;  
82.         int tempLine = line / 3;  
83.         for (int i = 0; i < 3; i++) {  
84.             for (int j = 0; j < 3; j++) {  
85.                 if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {  
86.                     return false;  
87.                 }  
88.             }  
89.         }  
90.   
91.         return true;  
92.     }  
93.   
94.     /** 
95.      * 打印矩阵 
96.      */  
97.     public void printArray() {  
98.         for (int i = 0; i < 9; i++) {  
99.             for (int j = 0; j < 9; j++) {  
100.                 System.out.print(matrix[i][j] + " ");  
101.             }  
102.             System.out.println();  
103.         }  
104.         System.out.println();  
105.     }  
106. }  

    可以看到，判断成功的标志是行号为8，且列号为9时，认为找到了正确解。为什么是9呢，因为在check(i,j,k)那一步，通过了的话，将值K赋给最后一个空格，此时并没有中断程序，而且进入了下一层循环backTrace（i，j + 1），所以i为8j为9时才是终解。程序到这里，运行一下看看，发现并没有任何输出值，并没有找到正确解，why？

    下面要讲的就是该程序最关键的地方，也是比较难以理解的地方，就是对根节点的初始化。回溯算法讲究的是一条道走到黑，不撞南墙不回头，并且把所有的道都走完。

    我们把问题简单化，譬如一共只有两个空格，只能放0和1，正确答案是00和11.我们给第一个空格放了0，此时我们不知道是否放了0之后，后面是否能完全正确的走完全程。就像走迷宫一样，你选择了第一个岔道，此时有可能第一个岔道就是错的，后面无论怎么走都对了不了，也有可能有多条道可以走。那么我们的做法是先第一步放0，发现没问题（符合只能放0和1的规则），然后走第二步，第二步如果走对了，那就直接走出去了，获得了一次正确的解（00）。如果第二步是个死胡同（01），那就要回头了，就是要回到原点，把第一步初始化一下，然后第一步走1，然后再继续后面的步骤。所以无论怎么样，你都需要在第二步走完之后，把第一步走的值给清掉，回归到原点。这样才能找到所有的正确路线。

    问题放大一下，有N步（N未知），第一步有1-9共9种情况，第一步放了1，后面还有未知的步，那无论后面成功与否，你肯定都要去试第一步放2-9之间的数字。

    看第51行for循环那里，第一次将数字1赋给第一个空格。然后判断是否OK，如果OK了，就进入第二个空格去了，后面具体走多少步我们就不管了，我们只需要在后面的走完之后，初始化第一个空格就行了。那要是不OK呢，不OK当然就不用管他了，这一层走完就没下文了，等于该分支就断了。所以我们要在第55行后面加一句初始化的操作matrix[i][j]=0.

   完整代码如下：

[java]  view plain  copy

 

1. package shudu;  
2.   
3. /** 
4.  * Created by wolf on 2016/3/17. 
5.  */  
6. public class Sudoku {  
7.     private int[][] matrix;  
8.   
9.     public Sudoku(int[][] matrix) {  
10.         this.matrix = matrix;  
11.     }  
12.   
13.     public static void main(String[] args) {  
14.         // 号称世界上最难数独  
15.         int[][] sudoku = {  
16.                 {8, 0, 0, 0, 0, 0, 0, 0, 0},  
17.                 {0, 0, 3, 6, 0, 0, 0, 0, 0},  
18.                 {0, 7, 0, 0, 9, 0, 2, 0, 0},  
19.                 {0, 5, 0, 0, 0, 7, 0, 0, 0},  
20.                 {0, 0, 0, 0, 4, 5, 7, 0, 0},  
21.                 {0, 0, 0, 1, 0, 0, 0, 3, 0},  
22.                 {0, 0, 1, 0, 0, 0, 0, 6, 8},  
23.                 {0, 0, 8, 5, 0, 0, 0, 1, 0},  
24.                 {0, 9, 0, 0, 0, 0, 4, 0, 0}};  
25.         Sudoku s = new Sudoku(sudoku);  
26.         s.backTrace(0, 0);  
27.     }  
28.   
29.     /** 
30.      * 数独算法 
31.      * 
32.      * @param i 行号 
33.      * @param j 列号 
34.      */  
35.     private void backTrace(int i, int j) {  
36.         if (i == 8 && j == 9) {  
37.             //已经成功了，打印数组即可  
38.             System.out.println("获取正确解");  
39.             printArray();  
40.             return;  
41.         }  
42.   
43.         //已经到了列末尾了，还没到行尾，就换行  
44.         if (j == 9) {  
45.             i++;  
46.             j = 0;  
47.         }  
48.   
49.         //如果i行j列是空格，那么才进入给空格填值的逻辑  
50.         if (matrix[i][j] == 0) {  
51.             for (int k = 1; k <= 9; k++) {  
52.                 //判断给i行j列放1-9中的任意一个数是否能满足规则  
53.                 if (check(i, j, k)) {  
54.                     //将该值赋给该空格，然后进入下一个空格  
55.                     matrix[i][j] = k;  
56.                     backTrace(i, j + 1);  
57.                     //初始化该空格  
58.                     matrix[i][j] = 0;  
59.                 }  
60.             }  
61.         } else {  
62.             //如果该位置已经有值了，就进入下一个空格进行计算  
63.             backTrace(i, j + 1);  
64.         }  
65.     }  
66.   
67.     /** 
68.      * 判断给某行某列赋值是否符合规则 
69.      * 
70.      * @param row    被赋值的行号 
71.      * @param line   被赋值的列号 
72.      * @param number 赋的值 
73.      * @return 
74.      */  
75.     private boolean check(int row, int line, int number) {  
76.         //判断该行该列是否有重复数字  
77.         for (int i = 0; i < 9; i++) {  
78.             if (matrix[row][i] == number || matrix[i][line] == number) {  
79.                 return false;  
80.             }  
81.         }  
82.         //判断小九宫格是否有重复  
83.         int tempRow = row / 3;  
84.         int tempLine = line / 3;  
85.         for (int i = 0; i < 3; i++) {  
86.             for (int j = 0; j < 3; j++) {  
87.                 if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {  
88.                     return false;  
89.                 }  
90.             }  
91.         }  
92.   
93.         return true;  
94.     }  
95.   
96.     /** 
97.      * 打印矩阵 
98.      */  
99.     public void printArray() {  
100.         for (int i = 0; i < 9; i++) {  
101.             for (int j = 0; j < 9; j++) {  
102.                 System.out.print(matrix[i][j] + " ");  
103.             }  
104.             System.out.println();  
105.         }  
106.         System.out.println();  
107.     }  
108. }