Question

A Sudoku puzzle consists of a 9 x9 grid which holds the numbers 1-9 in each space.The objective is to fill the grid with digits so that each column, each row, and each of the nine 3x3 sub-grids that compose the grid contain all of the digits from 1 to 9 (with no repeats). You are to write a recursive method that will construct a valid solution to the puzzle and return that solution. You may construct as many additional methods as are necessary The header of the methods is: public static int[]l] constructSolution)

Answer 1

Answer : make a SudokuPuzzel.java class and paste the given below code and run the program.Program has a Recursive method and perform the operation according to your question.

class SudokuPuzzle
{
   static int[][] board = new int[][]
           {
       {3, 0, 6, 5, 0, 8, 4, 0, 0},
       {5, 2, 0, 0, 0, 0, 0, 0, 0},
       {0, 8, 7, 0, 0, 0, 0, 3, 1},
       {0, 0, 3, 0, 1, 0, 0, 8, 0},
       {9, 0, 0, 8, 6, 3, 0, 0, 5},
       {0, 5, 0, 0, 9, 0, 6, 0, 0},
       {1, 3, 0, 0, 0, 0, 2, 5, 0},
       {0, 0, 0, 0, 0, 0, 0, 7, 4},
       {0, 0, 5, 2, 0, 6, 3, 0, 0}
           };
           static int N = board.length;
           public static boolean isSafeDriveSolution(int[][] board,
                   int row, int col,
                   int num)
           {
               // row has the unique (row-clash)
               for (int d = 0; d < board.length; d++)
               {
                   // if the number we are trying to
                   // place is already present in
                   // that row, return false;
                   if (board[row][d] == num)
                   {
                       return false;
                   }
               }
               // column has the unique numbers (column-clash)
               for (int r = 0; r < board.length; r++)
               {
                   // if the number we are trying to
                   // place is already present in
                   // that column, return false;

                   if (board[r][col] == num)
                   {
                       return false;
                   }
               }
               // corresponding square has
               // unique number (box-clash)
               int sqrt = (int) Math.sqrt(board.length);
               int boxRowStart = row - row % sqrt;
               int boxColStart = col - col % sqrt;

               for (int r = boxRowStart;
                       r < boxRowStart + sqrt; r++)
               {
                   for (int d = boxColStart;
                           d < boxColStart + sqrt; d++)
                   {
                       if (board[r][d] == num)
                       {
                           return false;
                       }
                   }
               }

               // if there is no clash, it's safe
               return true;
           }
           public static boolean driveSudokuPuzzle(int[][] board, int n)
           {
               int row = -1;
               int col = -1;
               boolean isEmpty = true;
               for (int i = 0; i < n; i++)
               {
                   for (int j = 0; j < n; j++)
                   {
                       if (board[i][j] == 0)
                       {
                           row = i;
                           col = j;
                           // we still have some remaining
                           // missing values in Sudoku
                           isEmpty = false;
                           break;
                       }
                   }
                   if (!isEmpty)
                   {
                       break;
                   }
               }
               // no empty space left
               if (isEmpty)
               {
                   return true;
               }

               // else for each-row backtrack
               for (int num = 1; num <= n; num++)
               {
                   if (isSafeDriveSolution(board, row, col, num))
                   {
                       board[row][col] = num;
                       //Recursive Calling........
                       if (driveSudokuPuzzle(board, n))
                       {
                           return true;
                       }
                       else
                       {
                           board[row][col] = 0; // replace it
                       }
                   }
               }
               return false;
           }
           public static void printSudokuPuzzle(int[][] board, int N)
           {
               // we got the answer, just print it
               for (int r = 0; r < N; r++)
               {
                   for (int d = 0; d < N; d++)
                   {
                       System.out.print(board[r][d]);
                       System.out.print(" ");
                   }
                   System.out.print("\n");

                   if ((r + 1) % (int) Math.sqrt(N) == 0)
                   {
                       System.out.print("");
                   }
               }
           }

           // Driver Code
           public static void main(String args[])
           {
               int [][] answer=constructSolution();
               printSudokuPuzzle(answer,answer.length); // print solution

           }
           private static int[][] constructSolution() {
               if (driveSudokuPuzzle(board, N))
               {
                   return board;
               }
               else
               {
                   System.out.println("No solution");
                   return null;
               }

           }
}