數獨 - 遞歸回溯可能 - 解決方案 - 計數器

Question

我正在處理一個小個人數獨並嘗試擴展它。

到目前爲止，我得到了「解決」部分工作，使用遞歸回溯方法，只要它設法解決遞歸返回true。

現在我正在嘗試構建一個獨特的解決方案電路板生成器，並且我在網上找到了相當多的關於如何實現它的信息。

但是，我在第一步掙扎，這是我的布爾遞歸回溯算法轉化爲遞歸算法，以保持可能的解決方案。這對檢查我生成的主板是否唯一至關重要。如何將布爾遞歸函數轉換爲返回某種count（int/long）的遞歸函數， ，而不會失去功能？有什麼樣的指導方針或技術可以遵循？

附加是迄今爲止的工作代碼。

import java.util.Scanner; 

public class Sudoku { 

    int[][] board; 

    public Sudoku(){} 

    public Sudoku(int n){ 
     this.board=new int[n][n]; 
    } 

    /* Creates an NxN game.board in a two-dimensional array*/ 
    public static int[][] createBoard(int n) 
    { 
     int[][] board = new int[n][n]; 
     for (int i=0; i<board.length; i++) 
      for (int j=0; j<board[i].length; j++) 
       board[i][j]=0; 
     return board; 
    } 

    /* prints the game.board*/ 
    public static void printBoard(int[][] b) 
    { 
     int buffer=(int)Math.sqrt(b.length); 
     // fitting the bottom line into any size of game.board 
     String btm=new String(new char[buffer*buffer*3+buffer+1]).replace("\0", "_"); 

     for (int i=0; i<b.length; i++) 
     { 
      if (i%buffer==0) 
       System.out.println(btm); 
      for (int j=0; j<b[i].length; j++) 
      { 
       if (j%buffer==0) 
        System.out.print("|"); 
       if (b[i][j]==0) 
        System.out.print(" _ "); 
       else 
        System.out.print(" " + b[i][j] + " "); 
      } 
      System.out.println("|"); 
     } 
     System.out.println(btm); 
    } 

    /* returns true if a number can be inserted in a row, otherwise returns false. */ 
    public static boolean checkLegalRow(int[][] b, int row, int num) 
    { 
     for (int i=0; i<b.length; i++) 
     { 
      if (b[row][i]==num) 
       return false; 
     } 
     return true; 
    } 
    /* returns true if a number can be inserted in a column, otherwise returns false.*/ 
    public static boolean checkLegalCol(int[][] b, int col, int num) 
    { 
     for (int i=0; i<b.length; i++) 
     { 
      if (b[i][col]==num) 
       return false; 
     } 
     return true; 
    } 

    /*returns true if number can be inserted in its local box.*/ 
    public static boolean checkLegalBox(int[][] b, int row, int col, int num) 
    { 
     int buffer=(int)Math.sqrt(b.length); 
     for (int i=0, adjRow=row-(row%buffer); i<buffer; i++, adjRow++) 
     { 
      for (int j=0, adjCol=col-(col%buffer); j<buffer; j++, adjCol++) 
      { 
       if (b[adjRow][adjCol]==num) 
        return false; 
      } 
     } 
     return true; 
    } 

    /*allows user input for a sudoku game.board*/ 
    public static void fillInBoardConsole(int[][] b) 
    { 
     Scanner sc = new Scanner(System.in); 
     System.out.print("Please enter a row: "); 
     int r=sc.nextInt(); 
     System.out.print("Please enter a column: "); 
     int c=sc.nextInt(); 
     System.out.print("Please enter a number from 1 to "+b.length+": "); 
     int num=sc.nextInt(); 
     while (num>b.length || num<1) 
     { 
      System.out.print("Please enter a number from 1 to "+b.length+": "); 
      num=sc.nextInt(); 
     } 
     b[r][c]=num; 
     sc.close(); 
    } 

    /* returns true if all the conditions for sudoku legal move are met: there is no 
* number on the same row, column, box, and the cell isn't taken*/ 
    public static boolean legalMove(int[][] b, int row, int col, int num) 
    { 
     return checkLegalRow(b,row,num) && checkLegalCol(b,col,num) && checkLegalBox(b,row,col,num) && b[row][col]==0; 
    } 

    /* returns true if the initial board setting is legal*/ 
    public static boolean initialLegal(int[][] b) 
    { 
     int num; 
     for (int i=0; i<b.length; i++) 
     { 
      for (int j=0; j<b[i].length; j++) 
      { 
       if (b[i][j]!=0) 
       { 
        num=b[i][j]; 
        b[i][j]=0; 
        if (!(checkLegalRow(b,i,num) && checkLegalCol(b,j,num) && checkLegalBox(b,i,j,num))) 
        { 
         b[i][j]=num; 
         return false; 
        } 
        else 
         b[i][j]=num; 
       } 
      } 
     } 
     return true; 
    } 

    /* using backtrack algorithm and recursion to solve the sudoku*/ 
    public static boolean solveBacktrack(int[][] b, int row, int col) 
    { 
     /*If the cell is already taken by a number: 
     * case 1: if its the last cell (rightmost, lowest) is already taken, sudoku solved 
     * case 2: if its the rightmost cell not on the if it is the rightmost column but not 
     * the lowest row, go to the leftmost cell in next row 
     * case 3: if it's a regular cell, go for the next cell*/ 
     if (b[row][col]!=0) 
     { 
      if (col==b.length-1) 
       if (row==b.length-1) 
       { 
        //printgame.board(b); // case 1 
        return true; 
       } 
       else 
        return solveBacktrack(b,row+1,0); // case 2 
      else 
       return solveBacktrack(b,row,col+1); // case 3 
     } 

     boolean solved=false; 

     for (int k=1; k<=b.length; k++) //iterates through all numbers from 1 to N 
     { 
      // If a certain number is a legal for a cell - use it 
      if (legalMove(b,row,col,k)) 
      { 
       b[row][col]=k; 
       if (col==b.length-1) // if it's the rightmost column 
       { 
        if (row==b.length-1) // and the lowest row - the sudoku is solved 
        { 
         //printgame.board(b); 
         return true; 
        } 
        else 
         solved=solveBacktrack(b,row+1,0); // if its not the lowest row - keep solving for next row 
       } 
       else // keep solving for the next cell 
        solved=solveBacktrack(b,row,col+1); 
      } 
      if (solved) 
       return true; 
      else //if down the recursion sudoku isn't solved-> remove the number (backtrack) 
      { 
       b[row][col]=0; 
      } 
     } 
     return solved; 
    } 

    /* public static long solveCountSolutions(int[][]b, int row, int col, long counter) 
    { 

    } 
    */ 


    public static void main(String[] args) 
    { 
     Sudoku game = new Sudoku(9); 
     game.board[0][2]=5;game.board[0][1]=3; game.board[0][0]=1; 
     game.board[8][2]=4;game.board[8][4]=3;game.board[8][6]=6; 
     printBoard(game.board); 
     if (initialLegal(game.board)) 
      System.out.println(solveBacktrack(game.board,0,0)); 
     else 
      System.out.println("Illegal setting"); 
     printBoard(game.board); 
    } 
} 

Answer 1

這樣的功能可以通過不從遞歸退出來實現時，找到解決辦法，而是轉儲解決方案的外部結構（如果你只需要計數，使計數器某處的功能之外，但可見的，一旦找到解決方案就增加它），然後繼續搜索，如果你已經死了。在這種（抽象的代碼）線的東西：

static int solutions=0; 
bool recursiveSolver(TYPE data) { 
    TYPE newData; 
    while (!nextChoice(data)) { 
     if (solved(data)) { 
      // return true; not now, we count instead 
      solutions++; 
     } 
     newData=applyNextChoice(data); // for recursion 
     if (recursiveSolver(newData)) { 
      return true; // will never hit, but checking is needed for solver to work 
     } 
    } 
    // all choices checked, no solution 
    return false; 
} 

applyNextChoice()是數獨中的情況下，「選擇下一個號碼，投入到這個細胞」的佔位符。 TYPE是代表不完整解決方案的任何結構的佔位符，在您的情況下爲int[][] b, int row, int col。