Announcements This Wednesday Class and Labs are cancelled

Announcements This Wednesday, Class and Labs are cancelled! The last lab is due this Wednesday … how many people are planning on doing it? Finally posted Exam 2 and solution on the website.

Backtracking Sudoku

Backtracking Problems seen so far: ◦ N Queens Problem ◦ Magic Number Square ◦ HW #5 – Tentaizu ◦ Recitation #9 - Maze

Backtracking For the maze problem, what do we need? ◦ Basically you need a nxn board that stores the empty spots and the wall spots. ◦ Then an nxn board that keeps track of what’s been used. Unlike the N Queens problem you don’t need to know what’s been “placed”, so the board and a used matrix will be sufficient. ◦ Then you basically just move forward through the maze and keep moving until you hit a dead end (hit a wall, or run off the board) or finish.

Sudoku has the following constraints: ◦ The rows must contain the numbers 1 -9 with no repeats. ◦ The columns must contain the numbers 1 -9 with no repeats. ◦ The boxes must contain the numbers 1 -9 with no repeats. 9 8 8 3 6 4 2 9 4 2 4 9 2 1 6 3 5 7 6 1 7 1 6 1 8 7 3 4 4 5

Sudoku What will we need to keep track of? ◦ Our current board int[][] answer ◦ Our available options for each square boolean[][][] options we read in the initial board, 9 8 3 6 4 4 Once ◦ We can update our options. If there is a number there, everything is set to false other than that number. If there is not a number there everything is true. 8 4 2 9 2 1 6 3 5 7 6 1 7 1 6 1 8 7 3 4 4 5

public class sudoku { private int[][] answer; private boolean[][][] options; • answer[][] will hold our current board. • options[][][] will hold the options available for each cell. // Constructor that sets up our answer board and our set of options. public sudoku(int[][] init. Board) { answer = new int[SIZE]; Read options = new boolean[SIZE][SIZE]; in the current answer board. for (int i=0; i<SIZE; i++) { for (int j=0; j<SIZE; j++) { answer[i][j] = init. Board[i][j]; // This is given to us on the initial board. If there is already a number if (init. Board[i][j] > 0) { there, all options are set to // Set all options to false except for the number for (int k=0; k<SIZE; k++) that spot. options[i][j][k] = false; // and the correct one to true. options[i][j][init. Board[i][j] - 1] = true; } // Open square for right now. else { for (int k=0; k<SIZE; k++) If BLANK, all options are true. options[i][j][k] = true; } at

Sudoku Now that we have our answer board and our options, how will we solve the Sudoku puzzle using backtracking? ◦ We need to check our current board to see if it is valid Are the rows ok? Are the columns ok? Are the boxes ok? If any are invalid, then we can return false. 9 8 3 6 4 4 ◦ We also need to reduce our options. Currently our options are only based on the initial board we filled in. We want to further reduce our options by looking at what is in each row, column and box. ◦ After all of that is done, we want to fill in the next “best” choice to make a guess. What cell would be the best cell to make a guess at? 8 4 2 9 2 1 6 3 5 7 6 1 7 1 6 1 8 7 3 4 4 5

public boolean go() { int my. Rows = check. Rows(); int my. Cols = check. Cols(); int my. Boxes = check. Boxes(); Determine whether any of the rows have been completely solved OR violate the constraints. // Base case: given a completed puzzle. if (my. Rows == SOLVED && my. Cols == SOLVED && my. Boxes == SOLVED) return true; See if the puzzle is already solved. // Base case: given an invalid puzzle. else if (my. Rows == INVALID || my. Cols == INVALID || my. Boxes == INVALID) return false; OR if any constraints are violated. // Redo our options here. reset(); reduce. Choice. Rows(); reduce. Choice. Cols(); reduce. Choice. Boxes(); // Choose the next square to "guess" at. int get. Next. Best. Sq = get. Best(); int next. Row = get. Next. Best. Sq/SIZE; int next. Col = get. Next. Best. Sq%SIZE; Then we reset our options here based on our current answer board. At this point we have checked all rows, and none of them violated our constraint.

for (int i=0; i<SIZE; i++) { if (options[next. Row][next. Col][i]) { Now we check each available option, for the next. Row, next. Col // Try this answer[next. Row][next. Col] = i+1; // See what happens here. boolean result = go(); If it’s possible, set the answer to the next available option Recursively solve the puzzle // If it works, immediately return true! if (result) return true; If that choice worked, we’re done! // If we get here, it didn't work, reset to 0 and try again. answer[next. Row][next. Col] = 0; // When we undo a choice, we have to redo our options. reset(); reduce. Choice. Rows(); reduce. Choice. Cols(); reduce. Choice. Boxes(); Otherwise, undo that choice and redo our options. } } // If none of our options worked, well, it's not solvable! return false; If none of our options worked, then it’s not solvable!

Sudoku Now that we have the basic algorithm, we still have to fill in the following methods: ◦ Check. Rows(), Check. Cols(), Check. Boxes() these will check if any of the rows, columns or boxes have been violated. ◦ Reduce. Choice. Rows(), Reduce. Choic. Cols(), Reduce. Choice. Boxes() these will update our options matrix to reduce the number of possible numbers that can be used in each cell. ◦ get. Best() will find the next box to fill in, it will return the one with the lease available options.

public int check. Rows() { boolean seen. Zero = false; Checks if the answer rows are consistent. Returns INVALID if not, VALID if so but there are empty squares // Go through each row. for (int row=0; row<SIZE; row++) { // At first, we've seen nothing. boolean[] done = new boolean[SIZE]; for (int k=0; k<SIZE; k++) done[k] = false; and SOLVED if all the rows are consistent and SOLVED. Which of the numbers 1 – 9 have been used in this row? Before we start looking they’re all false. // Now go through each number in this row. for (int col=0; col<SIZE; col++) { if (answer[row][col] == 0) seen. Zero = true; else if (done[answer[row][col] - 1]) return INVALID; else done[answer[row][col] - 1] = true; } } // end row // If we saw a zero, the puzzle isn't yet solved. if (seen. Zero) return VALID; If the current number has already been seen, there’s a duplicate! Otherwise, just mark that we’ve seen this number already. If we saw a zero, the rows aren’t solved. // The rows are solved properly, if we get here. return SOLVED; } If it’s zero, mark that the row is unfinished. Otherwise, the rows are solved!

Sudoku reduce. Choice. Rows() – reduce the options for each cell, based upon what the current answer of each row is. ◦ Go through each row For each row, Store which squares are open (at first they will all be open) Then, see if any are set to a value, if so mark it as closed. NOW, go through each square in this row that ISN’T set and put in the only appropriate options based upon what has been used already. public void reduce. Choice. Rows()

Suduko get. Best() – returns the square with the fewest number of options ◦ Goes through all rows and columns ◦ If a square is found that is not filled in (i. e. 0) Then determine how many choices are in that cell, and see if that beats our current choice. The spot will be returned as SIZE*row + col so that we can return a single int. public int get. Best()

Optional Homework Problem Fill in the Sudoku shell posted online and turn in a completed Sudoku solver.

References Slides adapted from Arup Guha’s Computer Science II Lecture notes: http: //www. cs. ucf. edu/~dmarino/ucf/cop 350 3/lectures/ Additional material from the textbook: Data Structures and Algorithm Analysis in Java (Second Edition) by Mark Allen Weiss Additional images: www. wikipedia. com xkcd. com