The N-queens Problem

Max GrooverChris WehuntForest Gates

Introduction

The N-queens problem is a constraint satisfaction problem that involves placing a

N amount of queens on a board of dimensions N by N squares so that no queens attack

each other. For no two queens to attack each other, two or more queens:

1. Must not be on the same row

2. Must not be on the same column

3. Must not be on the same top-right to bottom-left diagonal

4. Must not be on the same top-left to bottom-right diagonal

The eight-queens problem was first posed in 1841 by German chess composer

Max Bezzel in the Berliner Schachzeitung. Bezzel posed the question if eight queens

can be placed on standard eight-by-eight chessboard in a non-threatening fashion. The

first solutions were found by the legendary mathematician Carl Friedrich Gauss, who

tackled the problem at a leisurely pace in his own free time. All ninety-two solutions

were not published until the 1850s by Franz Nuack2. Discounting solutions that only

differ from other solutions by symmetrical properties of reflection or rotation, then there

is only 12 truly unique solutions to the eight-queens problem1. After Nuack had

published the first set of solutions, he proposed an extension to the original problem

involving placing N queens on a board of N by N dimensions. This is the problem we

are tackling.

For a standard sized chessboard of dimensions eight by eight squares. There is

a possible one-hundred seventy-eight and a half trillion blind placements of queens. All

of these combinations of queen placements must be checked for validity as a solution.

Using a computer, this is very resource-intensive. Finding more efficient ways of

generating and checking permutations of queen placements is a very common exercise

in algorithm design to this very day. In August 1971, E.W. Dijkstra detailed the eight-

queens problem during his time at the University of Texas at Austin. He solved this

problem using a depth-first backtracking algorithm to demonstrate his ideas of

structured programming, which is is the extensive use of computer logic to refine

computer programming3.

Formal Problem Statement

X - chessboard with N x N dimensions

Xrc - permutation of a queen at the Rth row and Cth column

Place N amount of queens Xrc on board X subject to:

Abstract

We will use three different algorithms to find a singular solution to the N-queens

problem and analyze their efficiency at finding said solution. The size of N starts at 4, as

there is no valid solutions at N = 2 or N = 3. At N = 1, any algorithm can find a solution

in constant time, thus N = 1 will be ignored. Each algorithm is run and timed at a given

N to determine their efficiency in finding a valid solution. If an algorithm takes an

untenable amount of time (in this case ten minutes) to find a solution at a certain value

of N, then N will no longer be incremented for testing with that algorithm. The N at which

the program took too long to find a solution will be recorded for later analysis and

comparison with other algorithms.

Algorithms will be analyzed for both their times at finding a solution and their

ability to efficiently find a valid solution at certain values of N in a reasonable amount of

time. The algorithms we have selected for experimentation are as follows:

● Brute force

● Backtracking

● Hill climbing

Brute Force

The brute force approach generates every possible combination of queen

placements, checking each one for validity as a solution using the four constraints

detailed above in the introduction and the formal problem statement. The unrefined

algorithm starts with the queens in an initial placement where the queens are placed in

the first row on each of the N columns, then iterates through all possible permutations

from the initial placements. Using this method, all possible permutations are exhausted

up to a possible 2N^N number of permutations.

There is a better way of doing this. Since we know that no queen can share a

row with another queen, we can assign a queen to each row. A queen on the first row

can be moved one column to the right, and all of the following queens can be moved in

such a way that successfully exhausted all possible permutations of the queen on that

row and column. Once this is done, the queen on the first row it moved one column over

and the process starts all over again. This reduced the amount of possible permutations

to N^N. Thus, the time complexity of this algorithm is O(N^N).

Figure 1. Graph showing the trendline for the bruteforce algorithm at different Ns.

The brute force algorithm can handle lower values of N efficiently. When N starts

to approach ten, the shortcomings of the algorithm start to become pronounced. When

N = 15, the solution time takes over ten minutes and is no longer considered viable for

use.

Backtracking

The Backtracking algorithm is a recursive approach to the N queens problem. It

works by iterating column by column, placing a single queen in each column. In each

column, it iterates over each row until a spot is found that has no conflicts with already

placed queens. The queen is placed here and the process is repeated in the following

column. If no safe spot exists in the given column, the algorithm reverts to the previous

column and finds a new spot for that queen. If none exists, it returns to the column

before that one, and so on, until a safe spot is found in each column. The “safe spots” in

this algorithm are determined by the four constraints provided by the formal statement

of the problem. If each constraint is satisfied, the queens have been safely placed on

the board. Because of the recursive nature of this algorithm, the worst case time

complexity is equal to O(n!).

Figure 2. Graphic shows the iterative process of backtracking for the n queens problem. This graphic goes row by row

instead of column by column like our implemented algorithm.

Certain changes can reduce the time this algorithm takes significantly. For

example, we added a line of code to start checking for safe spots in a column on the

third row instead of the first. If no safe spots exist in any other row, it reverts back to the

first two. We found that most collisions occur in these first two rows, so skipping them

reduces the total collisions by a considerable margin.

Figure 3. Graph showing the trendline for the backtracking algorithm at different Ns

The Backtracking algorithm is extremely fast with lower Ns up to around 30.

Once it hits 30, however, its worst case time complexity starts to become evident.

Hill Climbing

The Hill Climbing algorithm is a minimum-conflicts algorithm, it is also known as a

Greedy local search. Hill-climbing searches work by starting off with an initial state of a

solution by placing n queens on a n x n board, then iteratively making local changes to it

until either the solution is found or the heuristic gets stuck in a local maximum. The

algorithm always moves in the direction of increasing value(up the hill) and terminates

when no neighbor has a higher value. The heuristic method provides a score for each

problem based on the number of queen collisions. If the score is ten that means there

are ten collisions to be fixed before the problem is solved. If the heuristic score is zero

the problem is solved. There are many ways to try to avoid getting stuck in local

maxima, such as running many searches in parallel, or probabilistically choosing the

successor state, etc. A problem with the Hill Climbing technique is some arrangements

of queens preplaced on the board cannot be improved any further. This is called a local

minima.. The board would be stuck in a local minima if only two of the queens conflict

and the rest were fine. To fix this type of situation, one of the conflicting queens is

moved to a random row to create conflicts and start the process over again. In many

cases, hill-climbing algorithms will rapidly converge on the correct answer. However,

none of these approaches are guaranteed to find the optimal solution. The Big-O

Notation for the Hill Climbing algorithm is worst case O(n) and best case O(logn).

State: Position of the n queens, one per column or row

Successor States: are generated by moving a single queen to another space in its

column (n(n-1))

Cost of a State: number of constraint violations

Pseudo Code:

Hill Climbing = generate and test + heuristics

t = neighbor with a better heuristic score

1. Pick initial state s

2. Pick t in neighbors(s) with the largest f(t)

3. If f(t) <= f(s) then STOP, return s

4. If s = t Go Back to #2

Figure 4. Graph showing the trendline for the hill climbing algorithm at different Ns

This algorithm was very quick up until the mid 20’s. Once you get to 30 it is

downhill from there. This algorithm uses a heuristic which helps you look for an answer

but the results are subject to chance. The heuristic tells you only how to look not what to

find. This algorithm may fail to reach global maxima.

Figure 5This image explains how the heuristic function checks the best score from the neighbors and continues down to next set of neighbors and finds the best heuristic score until the score is zero which then returns the correct arrangement of queens.

Figure 6.This image shows the current state climbing the wrong hill to the local maximum instead of climbing the right hill behind it to find the

global maximum which would provide the correct solution.

Interpretation of results

For clarity of results in comparing the three algorithms, the trendlines for the

algorithms were used rather than the hard data for the graph comparisons. For both the

backtracking solution and hill climbing solution, often a solution could be found in forty

seconds for one solution while the next solution only took a single millisecond. Only the

brute force algorithm gave a consistent increase in times with a rise in the value of N.

Therefore, the trendlines were used in the comparisons.

Figure 7. A graph comparing the time efficiencies of all three algorithms

Comparing all the times of all three algorithms at the same N yields interesting

results. Brute force clearly lags behind the rest both in terms of time efficiency and

abilities to handle larger sizes of N. Backtracking is faster than hill climbing up to N = 30,

where backtracking is no longer able to continue based on our imposed time limit of ten

minutes. Hill climbing, despite appearing slower than backtracking, is able to handle a

larger N.

Conclusion

The most interesting takeaway from our results is that faster times does not

always mean a more efficient algorithm. While often it seems that the algorithm with the

fastest times is also able to handle the larger workloads, this is not always the case. It is

up to the user to determine what algorithm best fits the type of work they required done,

and the user should put extra research into determining whether faster times or an

ability to handle larger N values is more important.

Our experiment only covered three algorithms. There are many different

algorithms and variations that can be used to solve the N-queens problem such as

branch/bound and genetic. It is possible to achieve much faster times and handle much

larger values of N using some of these algorithms. Some very efficient algorithms can

allegedly handle Ns upwards of five hundred.

Future work would entail evaluating these other algorithms to determine their

efficiencies compared to the ones we have already looked into, and to see if they can

handle larger values of N. The algorithms we have used could also possibly be refined

to squeeze out even greater efficiency. It would be very interesting to find the absolute

biggest and baddest algorithm for solving N queens.

Works Cited

1) Wikipedia - Eight Queens Puzzle

https://en.wikipedia.org/wiki/Eight_queens_puzzle

2) The Initial n-Queens problem

http://www.math.armstrong.edu/faculty/brown/InitialNQueens.htm

3) EWD316: A Short Introduction to the Art of Programming by E.W. Dijkstra

https://www.cs.utexas.edu/users/EWD/transcriptions/EWD03xx/EWD316.9.html

4) Geeks for geeks https://www.geeksforgeeks.org/n-queen-problem-backtracking-

3/

5) CMU Lecture Notes http://www.cs.cmu.edu/~arielpro/15381f16/c_slides/781f16-

2a.pdf

6) N-Queens Research paper

https://pdfs.semanticscholar.org/88f6/ca4292fd72b24e005858041829dbc327674

3.pdf

http://www.math.armstrong.edu/faculty/brown/InitialNQueens.htm