MPI: Las Vegas
A Probabilistic Look At N-Queens
Joshua Patterson
I will be implementing and analyzing two simple Las Vegas style algorithms that
find a single solution to the N-Queens problem. Since Dr. Timothy Rolfe has already
implemented these algorithms using Java threads, it may be worthwhile to test the
performance of an implementation that uses MPI and compare it to Dr. Rolfe’s results.
Pseudo-code for the algorithms can be found on the following page.
Algorithm one:
The first algorithm works with three vectors. One is a permutation vector that
holds the column position of each queen. The other two vectors contain Boolean values
that mark which diagonals are in use.
To start the algorithm, the permutation vector is randomized and both diagonal
vectors are set to false. Then the first queen’s diagonals are marked true. The next, and
each subsequent queen’s position must first be checked to see if she lies on a used
diagonal. If she does not, move on to the next row. However, if she does lie on a used
diagonal, swap her row with row + 1. If her position is used as well, keep swapping with
row the next row until either a queen is found that does not lie on a used diagonal, or all
remaining queens have been tested. If no queen is found, the algorithm starts over
Algorithm two:
The second algorithm starts with an NxN Boolean matrix representing a board
with all positions marked as unblocked. A queen is then placed in row 0 at a random
position, and that queen’s column and diagonals are then marked as blocked as blocked
on the board.
Each subsequent queen is then placed at a random unblocked position on the next row.
If no unblocked position is found, the board is scrapped and the algorithm starts with a
new board.
Parallel solution:
Both algorithms can easily be broken into parallel processes simply by ensuring
that the random number generator in each process is given a sufficiently different seed.
The main challenge for the assignment will be determining a good exit strategy. Each
machine must be signaled to stop when a solution is found.
Dr. Rolfe’s analysis of his Java threads implementation can be found at:
http://penguin.ewu.edu/~trolfe/QueenLasVegas/
