5 queens on a 8x8 chess board - c++

Question

I am trying to find the number of ways possible to set 5 queens on a chess board without them being able to attack each other. I have succeeded to find the first set. The problem is how would I be able to find the next set of positions for 5 queens. The procedure in my program is like this:
Generate a vector of disallowed positions based on the current queens on the board
Loop through all the positions on the board
Check if the current position is one of the disallowed positions on the board
If it is not, return the position, add it to the vector of queens on the board and begin the process again
Continue until there is no more position available i.e. all the remaining positions are disallowed
#include <iostream>
#include <vector>
using namespace std;
const int BSIZE = 8;
char chessBoard[BSIZE][BSIZE];
struct qPos
{
qPos() : h(0), v(0), found(true) {}
int h; //horizontal pos
int v; //vertical pos
bool found; //if position is available
};
qPos findNextQPos(vector<qPos> Qs);
void fillBoard(vector<qPos> Qs);
void print();
vector<qPos> generateDisallowed(vector<qPos> Qs);
bool isDisallowed(qPos nextPos, vector<qPos> disallowedPos);
int main(int argc, char **argv){
vector<qPos> QsOnBoard; //Position of all the queens on board
qPos nextQ; //next possible position
while (nextQ.found)
{
nextQ = findNextQPos(QsOnBoard);
if (nextQ.found)
{
QsOnBoard.push_back(nextQ); //If the nextQ is available i.e. not disallowed, add it to the queens vector
}
}
fillBoard(QsOnBoard); //Fill the board with queens positions
print(); // print the board
return 0;
}
qPos findNextQPos(vector<qPos> Qs) {
// Generate disallowed positions based on all the queens on board
vector <qPos> disallowedPos = generateDisallowed(Qs);
qPos nextQ;
for (size_t i = 0; i < BSIZE; i++)
{
for (size_t j = 0; j < BSIZE; j++)
{
nextQ.h = i;
nextQ.v = j;
if (!isDisallowed(nextQ, disallowedPos)) { //Check if next possible position is a disallowed position
//cout << "Next available:\n" << nextQ.h << ", " << nextQ.v << endl;
return nextQ; // if it is avaible return the position, break the loop
}
}
}
nextQ.found = false; // No available position is found to return, found is set to false, return the position
return nextQ;
}
Rest of the source code where I have the other functions such as generate disallowed and isDisallowed and etc is on this pastebin. I thought it would not be really related to the question and the code here should not be too long.
The result of the first set looks like this:
So how should I continue in order to be able to find all solution sets? This is where I get stuck.

Answer 1

First, combine these two loops into one:
for (size_t i = 0; i < BSIZE; i++)
{
for (size_t j = 0; j < BSIZE; j++)
{
Instead:
for (size_t n = 0; n < (BSIZE * BSIZE); ++n)
{
size_t i = n % BSIZE;
size_t j = n / BSIZE;
Now your function can easily take a starting n. To find the "next" solution, simply remove the last queen (noting its position) and call FindNextQPos, telling it to start at the position one past that queen. If that queen is already at the last position, go back and remove another queen.
If you find no solution, do the same thing as if you do find a solution. Remove the last queen and call FindNextQPos, again starting one past the position of the queen you removed.
When you have no queens to remove, you are done.
You can do this with a single "continue" function. You can call this function whether you found a solution or found no solution. Its logic is:
Find the last queen. If there's no last queen, stop. We are done.
Note its position. Remove it.
Call FindNextQPos starting at the position one past the position we noted. If we placed a queen, keep trying to place more queens starting at position zero until we find a solution or can't place a queen.
If we found a solution, output it.
Go to step 1.