Introduction
When ordering old files, I found a lot of code. This is a program to find the solution to a jigsaw puzzle. I don't remember why I wrote it, it was a challenge I found interesting.
The Problem
There is a jigsaw. You have to put all the pieces in a square rectangle. You can flip and rotate pieces.
The solution
I wrote it first with an array of boards with pieces on it. Each piece that did fit without holes would be a new board. It was slow and it did use a lot of resources (for allocating arrays).
So I rewrote it in a way that the algorithm goes forward and backwards on the same board, adding and removing pieces.
The idea is pretty simple. You put the first piece (iterating an array of pieces). If it is OK, then you get to put the next one. If you can't, then you go backwards and remove it from the array. The only thing you have to remember is the order of the pieces so that when you go backwards, you can continue with the next piece.
The code  Loading the pieces
There are three classes for handling the pieces:
1111
0010
The class CPiezas
also has an array (map) with all the pieces (CPiezaInfo
) that it loads from the XML.
CPiezaInfo
: Contains information about the pieces and all its possible rotations and inversions. It contains a vector of CPieza
. Each CPieza
of the vector represents a possible rotation or inversion of the piece.
CPieza
: Each item of this class represents a piece in a rotated or inverted state. It has the colour and the methods for rotation and inversion. As there are 8 possible combinations of rotation and inversion (4 for rotation and 2 for inversion), the ID holds both the piece ID and the state.
For example, the ID 26 represents the piece ID:2, State:6. All possible states are defined in an enum TipoPieza
. This class inherits from CFillRectangle
which contains the general rectangle operations.
The code  Rectangle operations
The class CFillRectangle
is responsible for marking squares inside a rectangle. It was written with efficiency in mind (considering large vectors of boards). So, it uses binary logic to assign the squares. So, in a byte, 8 squares are used and marked as 1 or 0. This class is used for both boards and pieces.
The code  The board
The class CBoard
which inherits from CFillRectangle
represents the place to put the pieces. The variables are:
Fila
: Represents the current row to put a piece.
Columna
: Represents the current column to put a piece.
nodos
: An array of 12 items of type CNodo
. Each CNodo
represents a piece in a location of the board. Each CNodo
also has the index variable to move to the next piece in an array of pieces.
inodo
: Represents the current position being processed in the array nodos
(011).
nodeseval
: A counter for each piece that is being tried.
mappiezas
: A map that links each piece ID with the CPieza
object.
vecpiezas
: A vector to iterate pieces with the index variable of CNodo
.
mappiezasdisp
: A map that represents if the piece is in the board or not (the piece is available or not).
piezas
: A pointer to the pieces.
The methods are:
TieneHuecos
: Gets if the board has any unoccupied cells. This method is not used and could be removed.
MarcarCasillas
: Given a piece (a parameter of type CPieza
), it marks or unmarks all cells of the board that correspond to the piece in the current location of the board (variables Fila
and Columna
).
AsignarProxColumnaFila
: It assigns the board variables Fila
and Columna
to the first unmarked cell of the board from bottom to top, left to right.
CorrespondePieza
: Checks if placing a piece in the current board cell (Fila
and Columna
) can be done.
InitPiezasDisp
: Loads all the piece arrays (vecpiezas
, mappiezasdisp
, mappiezas
).
Init
: Loads the 12 nodes of nodos
and sets them to null.
MarcarPiezaInfo
: Given a piece, it marks or unmarks all of them in the map (in all positions) as available or not.
GetIndexFirstAvailable
: Gets the next piece in the vector vecpiezas
that is available (checks mappiezasdisp
).
The code  The solver
The class CPuzzleSolver
is where the algorithm takes place. The variable "soluciones
" is used to store solutions (array of 12 CNodo
). The variable solman
is an object of type CSolutionMan
used to filter duplicated solutions. The method SolvePuzzle
inits the board and the arrays, and executes the method HacerMovida
until user cancels or the algorithm finishes. A description of HacerMovida
:
if (Current piece index in current node is last + 1, go backwards)
{
Put null into current node.
Move backwards (go to the node before, index of nodes 1)
if (There are no more nodes before)
End Process.
Position the board in the coordinates of the current node.
Remove the piece of the current node from
the board (we need to move to the next piece).
Add the piece of current node to the list of available pieces.
Move to the next available piece in the current node.
}
else
{
if (Add the piece of the current node to the board)
{
Add the piece to the board (mark cells).
Remove the piece from the list of available pieces.
Assign the current node the coordinates of the board.
if (not find next free cell in the board, the board is full, solution)
{
Add Solution
Remove piece from board
Add piece to list of available pieces
Move to the next available piece in the current node.
}
else
{
Move to the next node (which is null).
Assign the node the first available piece from the list.
}
}
else
Move to the next available piece in the current node.
}
The code  Deleting duplicates
The class CSolutionMan
uses an array of type CSolPuntos
to delete duplicated solutions. The class CSolPuntos
, unlike the board (CFillRectangle
), contains an ID of piece instead of a boolean (1 or 0).
The idea is that, to check for duplicates, it is way easier to rotate or invert points in a board than pieces.
The algorithm is:
 Iterate solutions (i).
 For each solution, rotate, invert, rotate, and invert (result: 3 new solutions).
 Compare each remaining solution (ni sols) to the three solutions of the previous step.
 If equal, remove solution.
Algorithm X
There is a faster algorithm to solve this problem called Algorithm X developed by Donald Knuth. The most efficient implementation of this algorithm is dancing links.
The problem this algorithm resolves is "Exact cover". Basically, what it does is, given a matrix of 1s and 0s, find all rows that cover exactly once all columns with 1s:

A 
B 
C 
D 
P 
0 
1 
0 
1 
Q 
1 
0 
0 
0 
R 
1 
1 
0 
0 
S 
0 
0 
1 
0 
T 
0 
0 
1 
1 
In that example, the rows P, Q, and S and the rows R and T are the solutions for the given matrix. It seems simple, but for a larger matrix, finding all the solutions takes time.
The algorithm X consist of 4 steps that are executed until the matrix is null (a solution is found) or a column has all 0s (unsuccessful). Each iteration reduces the matrix size.
 Find the column with fewer 1s (if there is more than one, choose the first). For example, column A.
 For that column, choose a row where the intersection of the row and column is 1. Remember the row. For example, Row Q.
 For that row, choose the columns where the row value is 1 and for those columns, remove all rows where the value of the column is 1 (in this example, the only 1 of row Q is in column A, so remove rows Q and R).
 Remove the columns selected previously (A in this example).
After executing the steps, the matrix has column A removed and rows Q and R removed:

B 
C 
D 
P 
1 
0 
1 
S 
0 
1 
0 
T 
0 
1 
1 
Next we choose column B and from that column, Row P. We remember that row. From row P, we select columns B and D (where row P value is 1). Columns B and D have 1s in row T and P (of course). So, rows P and T go, and so columns B and D:
Here we select column C (we have little choice) and select Row S. Row S and column C go and we end with an empty matrix (success). The selected rows are Q, P, S. This is one solution.
To continue, we select the next 1 row of the column with fewer 1s (column A) in the original matrix. That row is Row R. Row R has 1s in columns A and B, so we select those columns. Those columns have 1s in rows P, Q, and R. So, rows P, Q, and R go, and so columns A and B:
Now the column with fewer 1s is column D. The first row with 1 is T. So we select Row T. Row T has 1s in columns C and D, which have 1s in all rows, so we end with an empty matrix again (success). The solution are rows R and T.
Implementation of Algorithm X, dancing links
For a large matrix, removing and restoring rows and columns are time expensive operations. Besides, in most problems, these matrixes are "sparse" which means that there are a lot of 0s and a few 1s. So, it is a good idea to only represent the 1s.
First we introduce the concept of double linked circular list:
Each item has two pointers, one to the left and one to the right. The final item points to the first.
To iterate the list moving to the right, starting with Item2
:
For (i = Item1.Right; i != Item1.Right; i = i.Right)
To remove an item (Item2
for example) using only Item2
:
Item2.Right.Left = Item2.Left
Here, we point Item3.Left
(Item2.Right.Left
) to Item2.Left
(Item1
) so that it "skips" Item2
. Item2.Right
is Item3
. Item2.Left
is Item1
.
Item2.Left.Right = Item2.Right
Here, we point Item1.Left
(Item2.Left.Right
) to Item2.Right
(Item3
) so that it "skips" Item2
. Item2.Left
is Item1
. Item2.Right
is Item3
.
To add an item (Item23
for example) at the right of Item2
(between Item2
and Item3
) using only Item2
:
Item2.Right.Left = Item23
Item2.Right = Item23
Here we point Item3.Left
to Item23
and Item2.Right
to Item23
. Item2.Right
is Item3
.
Item23.Right = Item2.Right
Item23.Left = Item2
Here we point Item23.Right
to Item3
(Item2.Right
) and Item23.Left
to Item2
.
Now, the problem of algorithm X can be represented with each 1 as a node and circular double links lists interlaced in a matrix with nodes that point up, down, left, and right. Representing the sample problem:
In this image, the node at Row S is alone in the row, so it points both left and right to itself. Each node also has a pointer to its column header (in the algorithm).
Representing the pentominoes problem as exact cover
We can represent the board as 60 "cells" to be filled. Each piece with its orientation, at a certain position in the board "covers" certain "cells". For example, the T piece, starting in the position 1 covers cells 1, 2, 3, 8, and 14.
So, we can make a grid with 60 columns, and represent every position (in the board) of each piece at all orientations. It is a pretty big matrix. But each piece can only be put in the board once, so we need to make sure it doesn't repeat. To do that, we add 12 columns (one for each piece) and we put a 1 in the corresponding piece. If the T piece is piece 3, the representation of the three boards filled with T piece starting at 1, 2, and 3 would be:
Of course, there are 60 board columns and I only represented 17, the rest of the columns have 0 values for this example. For this problem, it is a sparse matrix. Of 72 values for each row, only 6 will have 1 value (8%). The matrix has 1864 rows if we only consider a piece with 2 of 8 orientations to remove trivial solutions.
Trivial results
To avoid rotated or inverted solutions, you can use only 2 orientations out of a piece which allows 8 orientations.
Dancing links, the code
The two most important methods are the cover and uncover (or remove
and restore
). Given a col, they remove the col and all the rows where the col has an item. Visually, it's like removing a TV antenna:
void CDLinks::Remove(CColumnHeader* hcol)
{
hcol>right>left = hcol>left;
hcol>left>right = hcol>right;
for (CNode* row = hcol>down; row != hcol; row = row>down)
{
for (CNode* col = row>right; col != row; col = col>right)
{
col>down>up = col>up;
col>up>down = col>down;
col>header>len;
}
}
}
void CDLinks::Restore(CColumnHeader* hcol)
{
for (CNode* row = hcol>up; row != hcol; row = row>up)
{
for (CNode* col = row>left; col != row; col = col>left)
{
col>header>len++;
col>down>up = col;
col>up>down = col;
}
}
hcol>right>left = hcol;
hcol>left>right = hcol;
}
Results
In my laptop (slow), in 11 min 13 seconds, the program found 9356 solutions. After deleting duplicates, 2339 solutions remained (which is logically correct, 9356/4=2339). It checks for 288 949 150 nodes (try to put pieces in the board).
Using dancing links and avoiding trivial solutions, the program takes 14 seconds to find all the solutions.
This shows that dancing links is a much faster algorithm to calculate solutions for this kind of problems.
To improve speed, all the nodes are stored in a vector, with the reserve()
method. That way, there is only one allocation instead of one for each node being created.
Libraries
I migrated the solution to VS 2010. It uses MFC. The code compiles to both 32 and 64 bits.
Acknowledgements