Sudoku recursive backtracking, unrecursing too early

Question

So I am writing a sudoku solver in C++ and have run into a little snag. Below is my solve board code. It works for the first 3 rows of the puzzle, but unrecurses when hitting the end of the 4th row. Looking at the code on gdb it hits the end of the 4th row, backtracks to 6th column, tries and then unrecurses out to the end.

A couple of other notes about the code is the matrix which holds the sudoku board begins at 1,1 not 0,0. So when solveBoard is initially called the parameters are (1, 1, 0). I have also attached the setCell and checkConflicts functions for more insight on there. I have three vectors rowConf,colConf and squConf to store the values that have already been placed in the respective row, column, or square. I have been at this for hours and cannot get it to go past the 3rd row. Any assistance is greatly appreicated. Thanks!

EDIT: Added clearCell()

bool board::solveBoard(int i, int j, int count)
{

    if (j > 9)
    {
        j = 1;
        i++;

        printBoard();
        if (isSolved())
        {
            printBoard();
            cout <<"The Board has been solved!" <<endl
                 <<" The number of recursive calls was: " <<count <<endl;
            return true;
        }
     }

     if (isBlank(i, j))
     {
         for (int n = 1; n < 10; n++)
         {
             if (setCell(i, j, (char)n + '0'))
             {
                 if (solveBoard(i, j + 1, count + 1))
                 {
                     return true;
                 }
              }
          }
      }
      else
      {
          return (solveBoard(i, j + 1, count + 1));
      }

      clearCell(i, j);
      return false;
}

bool board::setCell(int i, int j, char val)
{
    int intVal;

    intVal = atoi(&val);

    if (i >= 1 && i <= BoardSize && j >= 1 && j <= BoardSize &&
        intVal >= 1 && intVal <= BoardSize)
    {
        if (!(checkConflicts(intVal, i, j, squareNumber(i, j))))
        {
        return false;
        }

        value[i][j] = intVal;

        // Set flags of the conflicts
        rowConf[i][intVal] = true;
        colConf[j][intVal] = true;
        squConf[squareNumber(i, j)][intVal] = true;

        return true;
    }
    else
    {
        throw rangeError("bad value in setCell");
    }
}

bool board::checkConflicts(int val, int i, int j, int k)
{
    if (i < 1 && i > BoardSize && j < 1 && j > BoardSize &&
        k < 1 && k > BoardSize && val < 1 && val > BoardSize)
    {
        throw rangeError("bad value in checkConflicts()");
    }

    if (rowConf[i][val] || colConf[j][val] || squConf[k][val])
    {
        return false;
    }
    else
    {
        return true;
    }
}

Initial Board:
 -----------------------------
| 3       |    8    |          -----------------------------
|         | 7       |       5  -----------------------------
| 1       |         |          ----------------------------- 
 -----------------------------
|         |         | 3  6     -----------------------------
|       2 |       4 |          -----------------------------
|    7    |         |          -----------------------------
 -----------------------------
|         |    6    | 1  3     -----------------------------
|    4  5 | 2       |          -----------------------------
|         |         | 8        -----------------------------
 -----------------------------

Final Output:
 -----------------------------
| 3  2  4 | 1  8  5 | 6  7  9  -----------------------------
| 6  8  9 | 7  2  3 | 4  1  5  -----------------------------
| 1  5  7 | 4  9  6 | 2  8  3  -----------------------------
 -----------------------------
|         |         | 3  6     -----------------------------
|       2 |       4 |          -----------------------------
|    7    |         |          -----------------------------
 -----------------------------
|         |    6    | 1  3     -----------------------------
|    4  5 | 2       |          -----------------------------
|         |         | 8        -----------------------------
 -----------------------------

void board::clearCell(int i, int j)
{
    int intVal;

    if (i >= 1 && i <= BoardSize && j >= 1 && j <= BoardSize)
    {
        if (value[i][j] != -1)
        {
            intVal = value[i][j];
            rowConf[i][intVal] = false;
            colConf[j][intVal] = false;
            squConf[squareNumber(i, j)][intVal] = false;
            value[i][j] = -1;
         }
    }
    else
    {
        throw rangeError("bad value in setCell");
    }
}

Does it output that the board is solved? That would be one possibility for the recursion to end. — phant0m, Nov 04 '12 at 10:44
I added the clear cell document. It never is declared solved. Whats happening is that for some reason it is unrecursing back to the beginning to try a new method since there is no available moves to place, but instead of moving to the next iteration of the for loop for the first blank cell, it hopes up one recursion and ends. — zberry92, Nov 04 '12 at 13:37
Yeah, it eventually gets back up to when i = 1 and j = 2. When it tries to place a value to try a new track the rowConf for that row says there is all the values except 9 there. So it places 9, moves on to 1,3 and can't place anymore choices because the code thinks there are no valid choices. For some reason it is not setting rowConf of that row back to false. — zberry92, Nov 04 '12 at 13:49
Ok my clearCell function is definitely screwy. It is not removing the flags in my conflict vectors correctly. — zberry92, Nov 04 '12 at 13:52
You know what, can you add *all* the other functions, too? That makes it easier instead of gradually asking for more ;) — phant0m, Nov 04 '12 at 16:20
I have tried to enter your test data (Initial Board) in my own solver and also in other solvers and they found no solution! Maybe you should start your tests with a board that has a solution ;) — Jens Schwarzer, Nov 08 '12 at 21:16

Fernando Cordeiro · Answer 1 · 2012-11-06T03:24:05.847

Your problem is most likely here:

if (isBlank(i, j))
 {
     for (int n = 1; n < 10; n++)
     {
         if (setCell(i, j, (char)n + '0'))
         {
             if (solveBoard(i, j + 1, count + 1))
             {
                 return true;
             }
          }
      }
  }

Somehow it is going through this section, which is why it isn't going through the else in the end, but since it hasn't returned before, it gets stuck.

This needs more debugging, but here is an idea that could lead to a solution:

if (isBlank(i, j))
{
    for (int n = 1; n < 10; n++)
    {
        if (setCell(i, j, (char)n + '0'))
        {
            if (solveBoard(i, j + 1, count + 1))
            {
                return true;
            } else {
                echo 'Looks like it ended on the farthest-level..';
          } 
      } else {
          echo 'Looks like it ended on the second-farthest level.';
      }
  }

Why do you have multiple `else` clauses? Also, your `else` basically says: `"If it didn't work the first time, let's try that once more"`. That is not going to work. — phant0m, Nov 05 '12 at 18:15
@phant0m, Thanks, editing. It's just one else for every "if" that didn't run. Anyways, my point is, looks like this is where it's exiting OP's code, and OP should find a way to track that. — Fernando Cordeiro, Nov 06 '12 at 03:23

CiaPan · Answer 2 · 2014-03-09T19:55:48.687

The atoi function expects a string as an argument, that is an array of chars terminated with character '\0', ASCII NUL. You give a parameter being a pointer to a character (equivalent to some arrray of chars) but do not guarantee it is zero-terminated. Please replace intVal = atoi(&val); with intVal = (int)val - '0';

And your checkConflicts should have || operators instead of && in the first if.

These are probably not reasons of the error but certainly need correction.

Sudoku recursive backtracking, unrecursing too early

2 Answers2