回溯演算法解數獨問題(java版)
下面來詳細講一下如何用回溯演算法來解數獨問題。
下圖是一個數獨題,也是號稱世界上最難的數獨。當然了,對於計算機程式來說,只要演算法是對的,難不難就不知道了,反正計算機又不累。回溯演算法基本上就是窮舉,解這種數獨類的問題邏輯比較簡單。
不管演算法懂不懂,先把類建出來,變數定義好,那放大學試卷上就是可以拿兩分了。
package shudu; /** * Created by wolf on 2016/3/17. */ public class Sudoku { private int[][] matrix; public Sudoku(int[][] matrix) { this.matrix = matrix; } public static void main(String[] args) { // 號稱世界上最難數獨 int[][] sudoku = { {8, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 3, 6, 0, 0, 0, 0, 0}, {0, 7, 0, 0, 9, 0, 2, 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}}; Sudoku s = new Sudoku(sudoku); s.backTrace(0, 0); } /** * 數獨演算法 * @param i * 行號 * @param j * 列號 */ private void backTrace(int i, int j) { } }
用一個二維陣列來儲存這個矩陣,然後定義一個方法來計算。方法裡有兩個屬性——行號和列號。
我們的原理就是從第0行0列開始,依次往裡面填入1-9之間的數字,然後判斷填入的這個數字是否能放進去(該行該列和它所在的小九宮格是否有重複數字)。如果能放進去,那麼就繼續用1-9去試該行的下一列。一直到該行的最後一列,然後換行繼續重複上面的步驟(也就是執行backTrace方法)。一直執行到最後一個空格,也就是i=8,j=8的時候,且最後這個空格所放的值也完全符合規則,那麼此時就算完成,不用再繼續呼叫backTrace方法了,輸出正確解即可。
所以回溯法樣子看起來是這樣的。給第一個空格填1-9中任何一個,開始判斷,如果OK,然後進入下一層,如果不OK,就斷掉了。下一層還是從1-9開始試,然後OK,不OK……當最終目標達到時,空格已填滿又滿足條件,那麼中斷該分支,輸出結果。
繼續我們的程式。
由於有些位置已經有數字了,所以我們需要判斷,如果該坑已經有人蹲了,那麼就把列號j加1,進入下一列。如果到第8列了,就換行。
修改程式如下:
此時已經寫好了判斷某行某列賦某個值是否ok的方法,通過該方法就能校驗出數字是否能放到該位置。package shudu; /** * Created by wolf on 2016/3/17. */ public class Sudoku { private int[][] matrix; public Sudoku(int[][] matrix) { this.matrix = matrix; } public static void main(String[] args) { // 號稱世界上最難數獨 int[][] sudoku = { {8, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 3, 6, 0, 0, 0, 0, 0}, {0, 7, 0, 0, 9, 0, 2, 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}}; Sudoku s = new Sudoku(sudoku); s.backTrace(0, 0); } /** * 數獨演算法 * * @param i 行號 * @param j 列號 */ private void backTrace(int i, int j) { //如果i行j列是空格,那麼才進入給空格填值的邏輯 if (matrix[i][j] == 0) { for (int k = 1; k <= 9; k++) { //判斷給i行j列放1-9中的任意一個數是否能滿足規則 if (check(i, j, k)) { //將該值賦給該空格,然後進入下一個空格 matrix[i][j] = k; backTrace(i, j + 1); } } } else { //如果該位置已經有值了,就進入下一個空格進行計算 backTrace(i, j + 1); } } /** * 判斷給某行某列賦值是否符合規則 * * @param row 被賦值的行號 * @param line 被賦值的列號 * @param number 賦的值 * @return */ private boolean check(int row, int line, int number) { //判斷該行該列是否有重複數字 for (int i = 0; i < 9; i++) { if (matrix[row][i] == number || matrix[i][line] == number) { return false; } } //判斷小九宮格是否有重複 int tempRow = row / 3; int tempLine = line / 3; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) { return false; } } } return true; } }
還缺少的是邊界值的判斷,就是當已經到最後一列了,還沒到最後一行時,需要對行號加1,然後恢復列號為0。
修改一下backTrace方法,增加邊界值判斷。
package shudu;
/**
* Created by wolf on 2016/3/17.
*/
public class Sudoku {
private int[][] matrix;
public Sudoku(int[][] matrix) {
this.matrix = matrix;
}
public static void main(String[] args) {
// 號稱世界上最難數獨
int[][] sudoku = {
{8, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 3, 6, 0, 0, 0, 0, 0},
{0, 7, 0, 0, 9, 0, 2, 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}};
Sudoku s = new Sudoku(sudoku);
s.backTrace(0, 0);
}
/**
* 數獨演算法
*
* @param i 行號
* @param j 列號
*/
private void backTrace(int i, int j) {
if (i == 8 && j == 9) {
//已經成功了,列印陣列即可
System.out.println("獲取正確解");
printArray();
return;
}
//已經到了列末尾了,還沒到行尾,就換行
if (j == 9) {
i++;
j = 0;
}
//如果i行j列是空格,那麼才進入給空格填值的邏輯
if (matrix[i][j] == 0) {
for (int k = 1; k <= 9; k++) {
//判斷給i行j列放1-9中的任意一個數是否能滿足規則
if (check(i, j, k)) {
//將該值賦給該空格,然後進入下一個空格
matrix[i][j] = k;
backTrace(i, j + 1);
}
}
} else {
//如果該位置已經有值了,就進入下一個空格進行計算
backTrace(i, j + 1);
}
}
/**
* 判斷給某行某列賦值是否符合規則
*
* @param row 被賦值的行號
* @param line 被賦值的列號
* @param number 賦的值
* @return
*/
private boolean check(int row, int line, int number) {
//判斷該行該列是否有重複數字
for (int i = 0; i < 9; i++) {
if (matrix[row][i] == number || matrix[i][line] == number) {
return false;
}
}
//判斷小九宮格是否有重複
int tempRow = row / 3;
int tempLine = line / 3;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {
return false;
}
}
}
return true;
}
/**
* 列印矩陣
*/
public void printArray() {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
System.out.println();
}
}
可以看到,判斷成功的標誌是行號為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.
完整程式碼如下:
package shudu;
/**
* Created by wolf on 2016/3/17.
*/
public class Sudoku {
private int[][] matrix;
public Sudoku(int[][] matrix) {
this.matrix = matrix;
}
public static void main(String[] args) {
// 號稱世界上最難數獨
int[][] sudoku = {
{8, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 3, 6, 0, 0, 0, 0, 0},
{0, 7, 0, 0, 9, 0, 2, 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}};
Sudoku s = new Sudoku(sudoku);
s.backTrace(0, 0);
}
/**
* 數獨演算法
*
* @param i 行號
* @param j 列號
*/
private void backTrace(int i, int j) {
if (i == 8 && j == 9) {
//已經成功了,列印陣列即可
System.out.println("獲取正確解");
printArray();
return;
}
//已經到了列末尾了,還沒到行尾,就換行
if (j == 9) {
i++;
j = 0;
}
//如果i行j列是空格,那麼才進入給空格填值的邏輯
if (matrix[i][j] == 0) {
for (int k = 1; k <= 9; k++) {
//判斷給i行j列放1-9中的任意一個數是否能滿足規則
if (check(i, j, k)) {
//將該值賦給該空格,然後進入下一個空格
matrix[i][j] = k;
backTrace(i, j + 1);
//初始化該空格
matrix[i][j] = 0;
}
}
} else {
//如果該位置已經有值了,就進入下一個空格進行計算
backTrace(i, j + 1);
}
}
/**
* 判斷給某行某列賦值是否符合規則
*
* @param row 被賦值的行號
* @param line 被賦值的列號
* @param number 賦的值
* @return
*/
private boolean check(int row, int line, int number) {
//判斷該行該列是否有重複數字
for (int i = 0; i < 9; i++) {
if (matrix[row][i] == number || matrix[i][line] == number) {
return false;
}
}
//判斷小九宮格是否有重複
int tempRow = row / 3;
int tempLine = line / 3;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (matrix[tempRow * 3 + i][tempLine * 3 + j] == number) {
return false;
}
}
}
return true;
}
/**
* 列印矩陣
*/
public void printArray() {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
System.out.println();
}
}