Question

I was solving the N Queen problem where we need to place 4 queens on a 4 X 4 chess board such that no two queens can attack each other. I tried this earlier but my approach did not involve backtracking, so I was trying again. The code snippets are

int size=4,i,j;
int arr[4][4];
int lastjindex[4]; // to store the last location which we may need to backtrack



void placeQueen(int i,int j)
{
    int availableornot=0;

    for(j=0;j<size;j++)
    {
        if(isAvailable(i,j)==1)
        {
            availableornot=1;
            break;
        }
    }

    if(availableornot==1)
    {
        arr[i][j]=1;
        lastjindex[i]=j;

        if((i+1)!=size)
        {
            placeQueen(i+1,0);
        }
    }

    else
    {
        // no column was availabe so we backtrack
        arr[i-1][lastjindex[i-1]]=0;
        placeQueen(i-1,lastjindex[i-1]+1);
    }
}

The isAvailable() method returns 1 if arr[i][j] is not under attack, else it returns 0.

int isAvailable(int i,int j)
{
    int m,n,flag=0;

    for(m=0;m<i;m++)
    {
        for(n=0;n<size;n++)
        {
            int k=abs(i-m);
            int l=abs(j-n);

            if(arr[m][j]==0 || arr[k][l]==0)
            {
                flag=1;
                break;
                // means that spot is available
            }
        }
    }
    return flag;
}

---

I call the above method from main as

placeQueen(0,0);

My program compiles successfully but it prints all zeroes.

---

Is there any problem with my recursion? Please help me correct my code as I am trying to learn how to implement backtracking algorithms!

---

Also I am not able to decide the base condition to end recursion. How do I choose it here?

Answer 1

There’s no printing in the code you posted. If you print after you have backtracked, you will be back to the initial condition of no queens on the board. Print after you have placed N queens, which is also the end condition for recursion. If you only want to print one solution, exit after printing, or set a flag that tells the caller that you’re done so you pop all the way out. If you print all solutions, that will include reflections and rotations. You can eliminate one axis of reflection by only placing queens within size/2 in the first level.

Also, there are some clear logic errors in you code, such as

arr[m][j]==0 || arr[k][l]==0

A queen can only be placed if it isn’t attacked on the file and it isn’t attacked along a diagonal. Use a debugger or add printfs to your code to trace where it is trying to place queens — that will help you figure out what it is doing wrong.

And aside from being wrong, your isAvailable is very inefficient. You want to know if the [i,j] square is attacked along the file or a diagonal. For that you should have a single loop over the rows of the previous queens for (m = 0; m < i; m++), but you only need three tests, not a loop, to check the file and the diagonals. As soon as you find any previous queen on a file or diagonal, you’re done, and the square isn’t available — return false. (And ignore people who tell you that a function should only have one return — they are wrong, and there are lengthly discussions here at SO and even scientific studies of error rates in code that bear this out.) Only if no previous queen is found is the square available.

Your placeQueen is also wrong. For each available square on a row, you need to place a queen and then recurse, but you’re just finding the first available square. And backtracking is achieved simply by removing the queen you placed and then returning … the previous level of placeQueen will try the next available spot.

Again, trace the code to see what it’s doing. And, even more importantly, think through the logic of what is needed. Write your algorithm in words, convince yourself that it will solve the problem, then write the code to carry out the algorithm.