Sudoku solver recursive backtracking not terminating - matlab

Question

I wrote a MATLAB program that solves a 9 x 9 Sudoku puzzle using the recursive backtracking solution, but the recursion does not seem to terminate. When I pause the debugger and look at the board, I find that that my board already contains the correct solutions. In my approach, I work through the board elements column by column, starting from element 1 in (1, 1) and ending at element 81 at (9, 9). checkSudoku checks if the number is a valid placement by looking at the row, col and 3x3 subgrid. h is where the recursion occurs. Could anyone offer advice as to where my code went wrong?
function result = h(board, num)
if num >= 82
result = board;
else
if isnan(board(num))
flag = false;
c = ceil(num / 9);
r = num - ((c - 1) * 9);
n = 1;
while (n <= 9) & (~flag)
if checkSudoku(board, r, c, n)
board(num) = n;
product = h(board, num + 1);
if ~isnan(product)
flag = true;
board(num) = n;
else
board(num) = NaN;
n = n + 1;
end
else
n = n + 1;
end
end
if ~flag
result = NaN;
else
result = h(board, num + 1);
end
else
result = h(board, num + 1);
end
end
end
function safe = checkSudoku(board, row, col, num)
r = row;
c = col;
subrow = board(r, :);
subcol = board(:, col);
subBoard = zeros(3, 3);
if any([1 2 3] == r)
if any([1 2 3] == c)
subBoard = board(1:3, 1:3);
elseif any([4 5 6] == c)
subBoard = board(1:3, 4:6);
else
subBoard = board(1:3, 7:9);
end
elseif any([4 5 6] == r)
if any([1 2 3] == c)
subBoard = board(4:6, 1:3);
elseif any([4 5 6] == c)
subBoard = board(4:6, 4:6);
else
subBoard = board(4:6, 7:9);
end
else
if any([1 2 3] == c)
subBoard = board(7:9, 1:3);
elseif any([4 5 6] == c)
subBoard = board(7:9, 4:6);
else
subBoard = board(7:9, 7:9);
end
end
if any(subrow == num)
safe = false;
elseif any(subcol == num)
safe = false;
elseif any(any(subBoard == num))
safe = false;
else
safe = true;
end
end
function solvedBoard = solveSudoku(board)
solvedBoard = h(board, 1);
end
I took the problem and the MATLAB file from MITOpenCourseWare, homework 3 optional question 3. The file and photo can be found here.

Answer 1

Recursive functions can be tricky to abstract even in the simple cases. Your case have a extra layer of complexity as on top of having to calculate things based on previous iterations, the algorithm should also be able to backtrack a certain number of iterations, before continuing the way forward.
I made a working example, but it is not the only way to achieve the result. The way I propose make use of two flags to help the recursive function knows in which direction it is going. You could do without flags but it would involve doing more checks during the function to assess the state of the board. Since the capability is there to use flags I made use of it to simplify.
I would strongly recommend you read the documentation on return as it is a useful tool for these types of functions.
Now on to the answer:
The starting board:
Firstly, for everybody's benefit, I present the starting unsolved board. It is a 9x9 matrix containing the initial numbers and NaN everywhere else.
unsolvedBoard = [
5 3 NaN NaN 7 NaN NaN NaN NaN
6 NaN NaN 1 9 5 NaN NaN NaN
NaN 9 8 NaN NaN NaN NaN 6 NaN
8 NaN NaN NaN 6 NaN NaN NaN 3
4 NaN NaN 8 NaN 3 NaN NaN 1
7 NaN NaN NaN 2 NaN NaN NaN 6
NaN 6 NaN NaN NaN NaN 2 8 NaN
NaN NaN NaN 4 1 9 NaN NaN 5
NaN NaN NaN NaN 8 NaN NaN 7 9 ] ;
The starting conditions:
Your algorithm was iterating blindly over all the 99 possible boxes of the grid. The problem statement recommended you to identify the empty indices in the grid (to be placed in a emptyInd variable, and only iterate through these empty indices thanks to a variable ind.
To incorporate that I modified the start of the main solver:
function solvedBoard = solveSudoku(board)
emptyInd = find(isnan(board)) ; % find the empty indices in the grid
% this will solve the board recursively
solvedBoard = solverec( board, emptyInd, 1 );
end
Now emptyInd contains only 51 indices to be found. We'll only iterate on these and not on the 99 boxes of the grid.
The possible numbers for a given box:
Your function checkSudoku(board, row, col, num) was working perfectly fine, but can be simplified. You were already converting row and column indices to linear indices in your h function, you can reuse the same type of calculations in this function to know the indices of the subrow/subcol/subBoard.
Also note that you can merge the if conditions with the logical or to check all the conditions at once.
The function can become:
function safe = checkSudoku(board, row, col, num)
subrow = board(row, :);
subcol = board(:, col);
subSquareRow = (1:3) + 3*(ceil(row/3)-1) ;
subSquareCol = (1:3) + 3*(ceil(col/3)-1) ;
subBoard = board( subSquareRow , subSquareCol );
subBoard = subBoard(:) ; % Reshape into column vector (easier comparison)
% This whole block can be replaced with the line described below
if any(subrow == num) || any(subcol == num) || any(any(subBoard == num))
safe = false;
else
safe = true;
end
% Note that since we are dealing with boolean, the "IF" check above could
% be avoided and simply written as :
% safe = ~( any(subrow == num) || any(subcol == num) || any(any(subBoard == num)) ) ;
end
Now this function is later used in the recursive loop to check if a number from 1 to 9 is valid in a given position. You used a while loop to run from 1 to 9. I find that wasteful to check nine numbers when we could know from the start the few possible candidates for a given box. So I wrote a function which return a list of the only possible valid number for a box. If it returns only 3 possible numbers, I will only have to iterate through these 3 numbers, instead of doing it blindly over 9 ot them.
function candidates = getCandidates(board, row, col)
subrow = board(row, :);
subcol = board(:, col);
subSquareRow = (1:3) + 3*(ceil(row/3)-1) ;
subSquareCol = (1:3) + 3*(ceil(col/3)-1) ;
subBoard = board( subSquareRow , subSquareCol );
subBoard = subBoard(:) ; % Reshape into column vector (easier comparison)
% Get the difference of each array compared to a reference line
refval = 1:9 ;
cdrow = setdiff(refval,subrow) ;
cdcol = setdiff(refval,subcol) ;
cdsqr = setdiff(refval,subBoard) ;
% intersection of the three arrays
candidates = intersect( intersect(cdrow,cdcol) , cdsqr ) ;
end
You can read up on setdiff and on intersect to understand how it works.
Now the recursive solver:
This function is doing the job of your h() function. You were having 2 main problems in your implementation:
Too many conditional branches: the program flow had too many if
branches, and some paths were actually never used. Even when it works
it is confusing, but often confusion also introduce errors.
No robust condition to check when the board was fully solved: you had a check,
but it wasn't capturing the board completion (in part due to the problem above).
What was hapening is when your board was fully solved, the algorithm has no way to detect that and work back through the iterative function call with the final result in hand. You algorithm was finding the solution, but with the lack of an exit door for this case (fully solved), it was defaulting to the other branches and eventually consistently reverting the last few iterations, even though they were correct.
The following implementation seem to work ok for our test case and a couple of other. You can try it on other cases if you want, just be aware that the grid must be solvable. I did not put any check or instruction on what to do if the grid is not solvable so I don't know what will happen if you run it on such a grid.
Code for solverec.m:
function [res, solved, noSolutionFound] = solverec(board,emptyInd,ind,solved)
%% initialise the return flag for first function call
if nargin < 4 ; solved = false ; end
noSolutionFound = false ; % initialise second flag
% check if we are done with all the EmptyInd
if ind>numel(emptyInd) ;
solved = true ;
end
%% Return quickly if the board is already solved
if solved
res = board ;
return ;
end
%% If we are here, we still have to find new emptyInd
% prepare useful indices (row, column & linear index)
num = emptyInd(ind) ;
col = ceil(num / 9);
row = num - ((col - 1) * 9);
% get possible candidates for this box
cd = getCandidates(board, row, col) ;
ncd = numel(cd) ; % number of candidates
if ncd == 0
% no candidate for this box => back track
noSolutionFound = true ;
else
% Try the possible candidates one by one
for k=1:ncd ;
board(num) = cd(k) ; % try one candidate
% move on to next emptyInd
[res, solved, noSolutionFound] = solverec(board,emptyInd,ind+1,solved) ;
% bail out if solved
if solved ; return ; end
% otherwise, reset this emptyInd before trying next candidate
if noSolutionFound
board(num) = NaN ;
end
end
end
if noSolutionFound
% We have exhausted all possible candidates for this emptyInd
% We have to back track further
board(num) = NaN ;
res = board ;
return % this one is actually optional, the function will "return"
% anyway at the end of the "if" block.
end
end
Testing:
>> solvedBoard = solveSudoku(unsolvedBoard)
solvedBoard =
5 3 4 6 7 8 9 1 2
6 7 2 1 9 5 3 4 8
1 9 8 3 4 2 5 6 7
8 5 9 7 6 1 4 2 3
4 2 6 8 5 3 7 9 1
7 1 3 9 2 4 8 5 6
9 6 1 5 3 7 2 8 4
2 8 7 4 1 9 6 3 5
3 4 5 2 8 6 1 7 9
I'll let you write the optional displaySudoku(board) function as an exercise ;)