java回溯算法解數獨問題

這篇文章主要爲大家詳細介紹了java回溯算法解數獨問題，具有一定的參考價值，感興趣的小夥伴們可以參考一下

本文實例爲大家分享了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列了，就換行。

修改程序如下：

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;
 }
}

此時已經寫好了判斷某行某列賦某個值是否ok的方法，通過該方法就能校驗出數字是否能放到該位置。
還缺少的是邊界值的判斷，就是當已經到最後一列了，還沒到最後一行時，需要對行號加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();
 }
}

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持神馬文庫。