Taming the Knight's Tour: Minimizing Turns and Crossings

TL;DR

This paper introduces new metrics for evaluating knight's tours based on turns and crossings, presents an efficient algorithm with provable approximation bounds, and extends these techniques to various board configurations and leapers.

Contribution

It proposes a novel algorithm for knight's tours that minimizes turns and crossings with proven approximation ratios and extends these methods to diverse chessboard variants and leapers.

Findings

Algorithm achieves $9.25n+O(1)$ turns and $12n+O(1)$ crossings.

Lower bounds of $(6-\epsilon)n$ turns and $4n-O(1)$ crossings established.

Algorithm runs in linear time and is fully parallelizable.

Abstract

We introduce two new metrics of "simplicity" for knight's tours: the number of turns and the number of crossings. We give a novel algorithm that produces tours with $9.25n+O(1)$ turns and $12n+O(1)$ crossings on an $n\times n$ board, and we show lower bounds of $(6-\epsilon)n$ and $4n-O(1)$ on the respective problems of minimizing these metrics. Hence, our algorithm achieves approximation ratios of $9.25/6+o(1)$ and $3+o(1)$. Our algorithm takes linear time and is fully parallelizable, i.e., the tour can be computed in $O(n^2/p)$ time using $p$ processors in the CREW PRAM model. We generalize our techniques to rectangular boards, high-dimensional boards, symmetric tours, odd boards with a missing corner, and tours for $(1,4)$-leapers. In doing so, we show that these extensions also admit a constant approximation ratio on the minimum number of turns, and on the number of crossings in most cases.

Tables

Table 1. Table 1: Result of applying each type of formation move, as well as three compositions of sequences of moves, to each formation matching.

	$\leftrightarrow$	$\updownarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow$	$\leftrightarrow \updownarrow$	$\updownarrow \leftrightarrow \updownarrow$
$V$	$V$	$X$	$V$	$H$	$X$	$H$
$H$	$H$	$H$	$X$	$X$	$V$	$V$
$X$	$X$	$V$	$H$	$V$	$H$	$X$

Table 2. Table 2: Cayley table for the group of positional matching permutations.

	$\leftrightarrow$	$\updownarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow$	$\leftrightarrow \updownarrow$	$\updownarrow \leftrightarrow \updownarrow$
$\leftrightarrow$	$\leftrightarrow$	$\updownarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow$	$\leftrightarrow \updownarrow$	$\updownarrow \leftrightarrow \updownarrow$
$\updownarrow$	$\updownarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow \updownarrow$	$\leftrightarrow \updownarrow$
$\leftrightarrow$	$\leftrightarrow$	$\leftrightarrow \updownarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow \updownarrow$	$\updownarrow$	$\updownarrow \leftrightarrow$
$\updownarrow \leftrightarrow$	$\updownarrow \leftrightarrow$	$\updownarrow \leftrightarrow \updownarrow$	$\updownarrow$	$\leftrightarrow \updownarrow$	$\leftrightarrow$	$\leftrightarrow$
$\leftrightarrow \updownarrow$	$\leftrightarrow \updownarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow \updownarrow$	$\leftrightarrow$	$\updownarrow \leftrightarrow$	$\updownarrow$
$\updownarrow \leftrightarrow \updownarrow$	$\updownarrow \leftrightarrow \updownarrow$	$\updownarrow \leftrightarrow$	$\leftrightarrow \updownarrow$	$\updownarrow$	$\leftrightarrow$	$\leftrightarrow$

Equations

$$\text{mbox}crown(a,b)=S(r_2(a),r_1(b))\cup S(r_3(a),r_2(b))\cup S(r_4(a),r_3(b)).$$

$$\frac{ALG(n)}{OPT(n)}<\frac{9.25}{6-ϵ}+\frac{ϵ}{2}<\frac{9.25+3ϵ}{6}+\frac{ϵ}{2}=\frac{9.25}{6}+ϵ$$

Full text

††journal: Arxiv

1 Introduction

The game of chess is a fruitful source of mathematical puzzles. The puzzles often blend an appealing aesthetic with interesting and deep combinatorial properties [1]. An old and well-known problem is the knight’s tour problem. A knight’s tour in a generalized $n\times m$ board is a path through all $nm$ cells such that any two consecutive cells are connected by a “knight move” (Figure 1). For a historic treatment of the problem, see [2]. A knight’s tour is closed if the last cell in the path is one knight move away from the first one. Otherwise, it is open. This paper focuses solely on closed tours, so henceforth we omit the distinction. The knight’s tour problem is a special case of the Hamiltonian cycle problem, in which we find a simple cycle that visits all the nodes for a specific class of graphs. These graphs are formed by representing each cell on the board as a node and connecting cells a knight move apart.

Existing work focuses on the questions of existence, counting, and construction algorithms.

In general, the goal of existing algorithms is to find any knight’s tour. We propose two new metrics that capture simplicity and structure in a knight’s tour.

We associate each cell in the board with a point $(i,j)$ in the plane, where $i$ represents the row and $j$ represents the column.

Definition 1** (Turn)**

Given a knight’s tour, a turn is a triplet of consecutive cells with non-colinear coordinates.

Problem 1** (Minimum turn knight’s tour)**

Given a rectangular $n\times m$ board such that a knight’s tour exists, find a knight’s tour minimizing the number of turns.

Definition 2** (Crossing)**

Given a knight’s tour, a crossing occurs when the two line segments corresponding to moves in the tour intersect. E.g. if $\{c_{1},c_{2}\}$ and $\{c_{3},c_{4}\}$ are two distinct pairs of consecutive cells visited along the tour, a crossing happens if the open line segments $(c_{1},c_{2})$ and $(c_{3},c_{4})$ intersect.

Problem 2** (Minimum crossing knight’s tour)**

Given a rectangular $n\times m$ board such that a knight’s tour exists, find a knight’s tour minimizing the number of crossings.

Knight’s tours are typically visualized by connecting consecutive cells by a line segment. Turns and crossings make the sequence harder to follow. Minimizing crossings is a central problem in graph drawing, the sub-field of graph theory concerned with the intelligible visualization of graphs (e.g., see the survey in [3]). Problem 2 is the natural adaptation for knight’s tours. Minimizing turns has many applications in computational geometry [4, 5, 6], where the number of turns in a polygonal line is sometimes referred to as link length [7, 8]. Problem 1 asks for the (self-intersecting) polygon with the smallest number of vertices that represents a valid knight’s tour.

1.1 Our contributions.

We propose a novel algorithm for finding knight’s tours with the following features.

$9.25n+O(1)$ turns and $12n+O(1)$ crossings on an $n\times n$ board.

• 2.

A $9.25/6+o(1)$ approximation factor on the minimum number of turns (Problem 1).555By $o(1)$, we mean a function $f(n)$ such that for any constant $\epsilon>0$, there is an $n_{0}$ such that, for all $n\geq n_{0}$, $f(n)<\epsilon$. The approximation factor is achieved by showing a $(6-\epsilon)n$ lower bound, for any $\epsilon>0$, on the number of turns of any knight’s tour (Theorem 8).

• 3.

A $3+o(1)$ approximation factor on the minimum number of crossings (Problem 2). The approximation factor is achieved by showing a $4n-O(1)$ lower bound on the number of crossings of any knight’s tour (Theorem 9).

• 4.

A $O(nm)$ run-time on an $n\times m$ board, i.e., linear on the number of cells, which is optimal.

• 5.

The algorithm is fully parallelizable: the tour can be computed in $O(nm/p)$ time with $O(p)$ processors in the CREW PRAM model (Theorem 4).

• 6.

It can be generalized to most typical variations of the problem: higher-dimensional cubical boards, rotationally symmetric tours, tours in boards with odd width and height that skip a corner cell, and tours for $(1,4)$-leapers, also known as giraffes, which move one cell in one dimension and four in the other.

• 7.

The algorithm can be simulated by hand with ease. This is of particular interest in the context of recreational mathematics and mathematics outreach.

The paper is organized as follows. Section 2 gives an overview of the literature on the knight’s tour problem and its variants. Section 3 describes the algorithm and its complexity analysis. We prove the approximation ratios in Section 4. Section 5 shows the mentioned variations. We conclude in Section 6. The tours produced by the algorithm can be visualized interactively for different board dimensions at http://nmamano.com/MinCrossingsKnightsTour.

2 Extended Related Work

Despite being over a thousand years old [1], the knight’s tour problem is still an active area of research. We review the key questions considered in the literature.

Existence. In rectangular boards, a tour exists as long as one dimension is even and the board size is large enough; no knight’s tour exists for dimensions $1\times n$, $2\times n$ or $4\times n$, for any $n\geq 1$ and, additionally, none exist for dimensions $3\times 6$ or $3\times 8$ [9]. In three dimensions or higher, the situation is similar: a tour exists only if at least one dimension is even and the board is large enough [10, 11, 12]. In the case of open knight’s tours, a tour exists in two dimensions if both dimensions are at least $5$ [13, 14].

Counting. The number of closed knight’s tours in an even-sized $n\times n$ board is at least $\Omega(1.35^{n^{2}})$ and at most $4^{n^{2}}$ [15]. The exact number of knight’s tours in the standard $8\times 8$ board is $26,534,728,821,064$ [16]. Algorithms for enumerating multiple [17] or all [18] knight’s tours have also been studied.

Algorithms. Historically, greedy algorithms have been popular for the knight’s tour problem. The idea is to construct the tour in order, one step at a time, according to some heuristic. Warnsdorff’s rule and its refinements [19, 18, 20] work well in practice for small boards, but do not scale to larger boards [21]. The basic idea is to choose the next node with fewest possible continuations, which is also useful for the Hamiltonian cycle problem [19].

To our knowledge, all efficient algorithms for arbitrary board sizes before this paper are based on a divide-and-conquer approach. The tour is solved for a finite set of small, constant-size boards. Then, the board is covered by these smaller tours like a mosaic. The small tours are connected into a single one by swapping a few carefully chosen knight moves. This can be done in a bottom-up [9, 14, 10, 11, 22] or a top-down recursive [23, 24] fashion. These processes are simple and can be done in time linear on the number of cells and, like ours, are also highly parallelizable [14, 23] since they are made of repeating patterns.

Divide-and-conquer is not suitable for finding tours with a small number of turns or crossings. Since each base solution has constant size, an $n\times n$ board is covered by $\Theta(n^{2})$ of them, and each one contains turns and crossings. Thus, the divide-and-conquer approach necessarily results in $\Theta(n^{2})$ turns and crossings. In contrast, our algorithm has $O(n)$ of each.

Extensions. The above questions have been considered in related settings. Extensions can be classified into three categories, which may overlap:

Tours with special properties. Our work can be seen as searching for tours with special properties. Magic knight’s tours are also in this category: tours such that the indices of each cell in the tour form a magic square (see [25] for a survey).

The study of symmetry in knight’s tours dates back at least to 1917 [27]. Symmetric tours under 90 degree rotations exist in $n\times n$ tours where $n\geq 6$ and $n$ is of the form $4k+2$ for some $k$ [28]. Parberry extended the divide-and-conquer approach to produce tours symmetric under 90 degree rotations [23]. Jelliss provided results on which rectangular board sizes can have which kinds of symmetry [29].

Both of our proposed problems are new, but minimizing crossings is related to the uncrossed knight’s tour problem, which asks to find the longest sequence of knight moves without any crossings [30, 31, 32, 33]. This strict constraint results in incomplete tours.

• 2.

Board variations. Besides higher dimensions, knight’s tours have been considered in other boards, such as torus boards, where the top and bottom edges are connected, and the left and right edges are also connected. Any rectangular torus board has a closed tour [34]. Another option is to consider boards with odd width and height. Since boards with an odd number of cells do not have tours, it is common to search for tours that skip a specific cell, such as a corner cell [23].

• 3.

Move variations. An $(i,j)$-leaper is a generalized knight that moves $i$ cells in one dimension and $j$ in the other [35]. The knight is a $(1,2)$-leaper. Knuth studied the existence of tours for general $(i,j)$-leapers in rectangular boards [36]. Tours for giraffes ($(4,1)$-leapers) were provided in [28] using a divide-and-conquer approach. Chia and Ong [37] studied which board sizes admit generalized $(a,b)$-leaper tours. Kamčev [22] showed that any board with sufficiently large and even size admits $(2,3)$-, $(2,5)$-, and $(a,1)$-leaper tours for any even $a$, and generalized this to any higher dimensions. Note that $a$ and $b$ are required to be coprime and not both odd, or no tour can exist [22].

3 The Algorithm

Given that one of the dimensions must be even for a tour to exist, we assume, without loss of generality, that the width $w$ of the board is even, while the height $h$ can be even or odd. We also assume that $w\geq 16$ and $h\geq 12$. The construction still works for some smaller sizes, but may require tweaks to its most general form described here.

Quartet moves. What makes the knight’s tour problem challenging is that knight jumps leave “gaps”. Our first crucial observation is that a quartet of four knights arranged in a square $2\times 2$ formation can move “like a king”: they can move horizontally, vertically, or diagonally without leaving any gaps (Figure 2).

By using the “formation moves” depicted in Figure 2, four knights can easily cover the board moving vertically and horizontally while remaining in formation. Of course, we need to traverse the entire board in a single cycle, not four paths. Thihs is solved with special structures placed in the bottom-left and top-right corners of the board, which we call junctions, and which tie the four paths together to create a single cycle. Using only straight formation moves leads to tours with a large number of turns and crossings. Fortunately, two consecutive diagonal moves in the same direction introduces no turns or crossings, so our main idea is to use as many diagonal moves as possible. This leads to the general pattern in Figure 3.

The full algorithm is Algorithm 1. The formation starts at a junction at the bottom-left corner and ends at a junction at the top-right corner. To get from one to the other, it zigzags along an odd number of parallel diagonals, alternating between downward-right and upward-left directions. The junctions in Figure 4 have a height, which influences the number of diagonals traversed by the formation.

At the bottom-left corner, we use a junction with height 5. At the top-right corner, we use a junction with height between 5 and 8. Choosing the height as in Algorithm 1 guarantees that, for any board dimensions, an odd number of diagonals fit between the two junctions. Sequence $1$ in Figure 5, which we call the heel, is used to transition between diagonals along the top and bottom edges of the board. The two non-junction corners require special sequences of quartet moves, as depicted in Figure 5. Sequences $1,2,3,$ and [math] are used when the last heel ends $0,2,4,$ and $6$ columns away from the vertical edge, respectively. These variations and the top-right junction are predictable because they cycle as the board dimensions grow, so in Algorithm 1 we give expressions for them in terms of $w$ and $h$.

Figure 6 shows the manifestation of these variations in different board dimensions. The sequence of quartet moves is easy to construct by hand. One starts from the bottom-left junction, which is always the same. One can then proceed in order. The other corners can be figured out as one encounters them. For the non-junction ones, one need only keep in mind that if the usual heel does not reach the right edge exactly, at least four columns are needed for the next transition. For instance, in Sequence $2$ in Figure 5, the last heel is cut short to leave four columns instead of two. At the final corner, simply stop when there are between 5 and 8 rows left along the right edge, and plug in the corner of the appropriate size.

3.1 Correctness

It is clear that the construction visits every cell, and that every node in the underlying graph of knight moves has degree two. However, it remains to be argued that the construction is actually a single closed cycle for any board dimensions. For this, we need to consider the choice of junctions.

A junction is a pair of disjoint knight paths whose four endpoints are adjacent as in the quartet formation. Thus, the paths in the bottom-left junction connect the four knights in two pairs. Denote the four knight positions in the formation by $tl,tr,bl,br$, where the first letter indicates top/bottom and the second left/right. We consider the three possible positional matchings with respect to these positions: horizontal matching $H=(tl,tr),(bl,br)$, vertical matching $V=(tl,bl),(tr,br)$, and cross matching $X=(tl,br),(tr,bl)$. Let $\mathcal{M}=\{H,V,X\}$ denote the set of positional matchings. We are interested in the effect of executing formation moves on the positional matching. A formation move does not change which knights are matched with which, but a non-diagonal move changes their positions, and thus their matchings. For instance, a horizontal matching becomes a cross matching after a straight move to the right.

It is easy to see that a straight move upwards or downwards has the same effect on the positional matching. Similarly for left and right straight moves. Thus, we classify the formation moves in Figure 2 (excluding double straight moves, which are a composition of two straight moves) into vertical straight moves $\updownarrow$, horizontal straight moves $\leftrightarrow$, and diagonal moves

$\leftrightarrow$

. Let \mathcal{S}=\{\updownarrow,\leftrightarrow,\begin{turn}{45.0}\raisebox{-4.30554pt}{\leftrightarrow}\end{turn}\} denote the three types of quartet moves. We see each move type $s\in\mathcal{S}$ as a function $s:\mathcal{M}\to\mathcal{M}$. The move types in $\mathcal{S}$, seen as functions are, in fact, permutations (see first three columns in Table 1). For example, the diagonal move

$\leftrightarrow$

is just the identity. It follows that any sequence of formation moves permutes the positional matchings, according to the composed permutation of each move in the sequence. The composed permutation of a sequence of moves $S=(s_{1},\ldots,s_{k})$, where each $s_{i}\in\mathcal{S}$, on a given positional matching $M\in\mathcal{M}$ is $S(M)=s_{1}\circ\cdots\circ s_{k}(M)$. There are six possible permutations of the three positional matchings, three of which correspond to the “atomic” formation moves \begin{turn}{45.0}\raisebox{-4.30554pt}{\leftrightarrow}\end{turn},\updownarrow, and $\leftrightarrow$. The other three permutations can be obtained by composing atomic moves, for instance, with the compositions $\updownarrow\leftrightarrow,\leftrightarrow\updownarrow,$ and $\updownarrow\leftrightarrow\updownarrow$ (Table 1). Thus, any sequence of moves permutes the positional matchings in the same way as one of the sequences in the set \{\begin{turn}{45.0}\raisebox{-4.30554pt}{\leftrightarrow}\end{turn},\updownarrow,\leftrightarrow,\updownarrow\leftrightarrow,\leftrightarrow\updownarrow,\updownarrow\leftrightarrow\updownarrow\}. This is equivalent to saying that this set, under the composition operation, is isomorphic to the symmetric group of degree three. Table 2 shows the Cayley table of this group.

Let $T_{w,h}$ be the sequence of formation moves that goes from the bottom-left junction to the top-right one in Algorithm 1 in a $w\times h$ board.

Lemma 1

For any even $w\geq 16$ and any $h\geq 12$, $T_{w,h}(H)=H$.

Proof 1

We show that the entire sequence of moves $T_{w,h}$ is either neutral or equivalent to a single vertical move, depending on the board dimensions. According to Table 1, this suffices to prove the lemma.

*The sequence $T_{w,h}$ consists mostly of diagonal moves, which are neutral. The transition between diagonals along the vertical edges consist of two vertical moves, which are also neutral (\updownarrow\updownarrow=\begin{turn}{45.0}\raisebox{-4.30554pt}{\leftrightarrow}\end{turn}). The heel is also neutral, as it consists of the sequence $\updownarrow\updownarrow\leftrightarrow\leftrightarrow\updownarrow\leftrightarrow\leftrightarrow\updownarrow$ (omitting diagonal moves) which is again equivalent to

$\leftrightarrow$

. This is easily seen by noting that any two consecutive vertical or horizontal moves cancel out. For instance, Figure 7 shows that if the positional formation is $H$ when entering the heel, then it is also $H$ when leaving the heel. Thus, $T_{w,h}$ can be reduced to the composition of the sequences in the bottom-right and top-left corners shown in Figure 5. As mentioned, Sequence 1, the heel, is neutral. It is easy to see that the other sequences (counting each part of Sequence 2 separately) is equivalent to $\updownarrow$. Thus, we get that $T_{w,h}$ is simply the composition of zero to four vertical moves, depending on the width and height of the board. Since two consecutive vertical moves cancel out, this further simplifies to zero or one vertical moves.*

Theorem 2** (Correctness)**

Algorithm 1 outputs a valid knight’s tour in any board with even width $w\geq 16$ and with height $h\geq 12$.

Proof 2

Clearly, the formation moves in our construction yield a set of disjoint cycles in the underlying knight-move graph. We prove that they actually form a single cycle. Given a set of disjoint cycles in a graph, contracting a node in one of the cycles is the process of removing it and connecting its two neighbors in the cycle. Contracting a node in a cycle of length $\geq 3$ does not change the number of cycles. Thus, consider the remaining graph if we contract all the nodes except the four endpoints of the top-right junction.

Since we use a vertical matching in the top-right junction, contracting the non-endpoint nodes inside the top-right junction leaves the two edges corresponding to the vertical matching. In the bottom-left junction we use a horizontal matching so, by Lemma 1, contracting the nodes outside the top-right junction leaves the edges corresponding to a horizontal matching. Thus, the resulting graph is a single cycle of four nodes.

The choice of matchings at the junctions is important; using a horizontal matching in the top-right junction would not result in a knight’s tour. On the other hand, the shapes of the junctions are not important. We use the junctions in Figure 4 because they fit nicely with the rest of the construction, but alternative shapes are possible. As an alternative, Figure 8 shows a $6\times 6$ junction which can replace all the junctions in Figure 4.

3.2 Parallel Implementation

Algorithms 1 only uses the width and the height of the board to determine the configuration on the corners. Consequently, we can determine the two knight moves incident on each cell in constant time: there is a constant number of cells near the corners; the moves in the first and last two columns are based on repeating vertical formation moves; the moves in the first and last four rows are based on the repeating heel pattern; and the remaining moves are based on the diagonal formation moves.

Besides knowing the two knight moves incident on each cell, we can also find, in constant time, where the knight will be after a certain number of moves.

Lemma 3

Let $T$ be the tour produced by Algorithm 1 on a board with even width $w\geq 16$ and height $h\geq 12$. Assuming that the knight starts at the bottom-left cell $(1,1)$, we can, for any $i$ between $1$ and $w\cdot h$, the $i$-th cell in $T$ using a constant number of arithmetic operations.

Proof 3

For concreteness, we assume that $w\equiv 6\ (\mathrm{mod}\ 8)$ and $h\equiv 2\ (\mathrm{mod}\ 4)$. According to Algorithm 1, this means that the bottom-right and top-left edges have a heel shape. This is one of a constant number of cases regarding the values of $w\mbox{ mod }8$ and $h\mbox{ mod }4$. The other cases follow a similar argument, but with a slightly different case analysis.

The tour $T$ is divided into 8 sections: the paths of the four formation knights and the 2 paths in each junction (each section has a different color in Figure 3). The path of each formation knight can be further divided into three sections that follow regular patterns (Figure 9): starting from the bottom-left corner, the first section follows formation moves between the left and bottom edges. The second section follows formation moves between the top and bottom edges or between the left and right edges (as in Figure 3), depending on the dimensions of the board. The third section follows formation moves between the top and right edges. The length of each of these sections is an arithmetic (quadratic) function of $w$ and $h$, so we can calculate their lengths and map the index $i$ to one of these sections.

Once we know which section index $i$ belongs to, we can find the exact cell within the section. For concreteness, we assume that $i$ belongs to the section $S$ after the knight leaves the bottom-left junction for the first time and before the formation reaches the top-left or bottom-right corners (Section 1 in Figure 9). This corresponds to the black path in Figure 10. Again, the other sections can be analyzed using a similar argument.

The index of the first cell in $S$ is $7$, since indices $1$ to $6$ correspond to cells inside the bottom-left junction (the red path in Figure 10). We call the cells of $S$ in column $1$ waymarks. Figure 10 shows that the index increment between two consecutive waymarks is $8$ more than between the previous pair. This is because each waymark is $4$ rows above the previous one, so the path between two waymarks has to go down and up $4$ more rows than the previous pair using diagonal formation moves, which only go up or down one row at a time.

Given an index $i$ in $S$, the number of waymarks before or at index $i$ is $\lfloor\frac{\sqrt{i+2}-1}{2}\rfloor$. Hence, we can find the last waymark $x$ before (or at) index $i$, its row $r_{x}$, its index $i_{x}$, and the index offset $k$ since the last waymark, $k=i-i_{x}$. Given these values, we can find the cell at index $i$. We consider three cases: if $r_{x}-k\geq 4$ the cell is between the waymark and the heel, and its coordinates are $(r_{x}-k,1+2k)$; if $4>r_{x}-k\geq-1$ the cell is one of the five cells in the heel; otherwise, it is between the heel and the next waymark.

For example, if index $85$ is in $S$, then, there are $\lfloor\frac{\sqrt{85+2}-1}{2}\rfloor=4$ waymarks before that index, the last one has index $79$, and its coordinates are $(19,1)$. The offset since the last waymark is $85-79=6$, so the cell at index $85$ is $(19-6,1+12)=(13,13)$.

Theorem 4

Algorithm 1 can be computed in $O(wh/p)$ time using $p$ processors in the CREW PRAM model on a board with even width $w\geq 16$ and height $h\geq 12$, assuming arithmetic operations on numbers of the order of $w$ and $h$ take constant time.

Proof 4

Lemma 3 states that each index can be computed independently of the rest, so each processor can compute a section of the tour without any data dependencies between processors.

4 Approximation Ratios

In this section, we analyze the approximation ratio that our algorithm achieves for the problems of minimizing turns and crossings. For simplicity, we restrict the analysis to square boards. First, we briefly discuss the classification of these problems in complexity classes.

4.1 Computational Complexity

Consider the following decision versions of the problems: is there a knight’s tour on an $n\times n$ board with at most $k$ turns (resp. crossings)? We do not know if these problems are in $\mathsf{P}$. Furthermore, it may depend on how the input is encoded. Technically, the input consists of two numbers, $n$ and $k$, which can be encoded in $O(\log n+\log k)$ bits. However, it is more natural to do the analysis as a function of the board size (or, equivalently, of the underlying graph on which we are solving the Hamiltonian Cycle problem), that is, $\Theta(n^{2})$. It is plausible that the optimal number of turns (resp. crossings) is a simple arithmetic function of $n$. This would be the case if the optimal tour follows a predictable pattern like our construction, where counting the number of turns or crossings does not require recreating the tour. If this were the case, the problems would be in $\mathsf{P}$ regardless of the input’s encoding.

If the input is represented using $\Theta(n^{2})$ space, the problems are clearly in $\mathsf{NP}$, as a tour with $k$ turns (resp. crossings) acts as a certificate of polynomial length.

However, unless $\mathsf{P}=\mathsf{NP}$, the problems are not $\mathsf{NP}$-hard: consider the language $\{1^{n}01^{k}\mid\mbox{ a tour exists with at most }k\mbox{ turns in an }n\times n\mbox{ board}\},$ and the analogous language for crossings. These languages are sparse, meaning that, for any given word length, there is a polynomial number of words of that length in the language. Mahaney’s theorem states that if a sparse language is $\mathsf{NP}$-complete, then $\mathsf{P}=\mathsf{NP}$ [38]. This suggests that the problems are in $\mathsf{P}$, though technically they could also be $\mathsf{NP}$-intermediate.

If the input is represented using $O(\log n+\log k)$ bits, then the problems are in $\mathsf{NEXP}$ because the versions above where the input takes $\Theta(n^{2})$ bits are in $\mathsf{NP}$. In this setting, simply listing a tour would require time exponential on the input size.

4.2 Upper Bounds

We use our algorithm to find upper bounds on the optimal solutions to Problem 1 and Problem 2. All the turns and crossings in our construction happen near the edges. The four corners account for a constant number of each. The left and right edges have 8 turns and 10 crossings for each four rows. The heel from Figure 7 has 22 turns and 32 crossings, so the top and bottom edges have that many turns and crossings for each eight columns.

We can reduce the number of turns and crossings slightly by replacing each heel with an alternative set of knight moves that cover the same cells and start and end with the four knights in the same place. In other words, we allow the four knights to temporarily “break formation” when they reach the heel and reassemble before leaving it in the next diagonal.

We did an exhaustive search for four knights that cover the squares shown in Figure 11, starting and ending in the two groups of four cells on the top-left. Of all the possible solutions, Figure 11 shows two: one minimizing the number of turns and one minimizing the number of crossings. There is no single solution minimizing both. Turns and crossings caused by the path continuations outside the heel are also counted. In our search, the four knights are not required to end in any specific configuration, but the optimal solutions happen to end in the same configuration as the original heel.

Our construction with the optimized heels has $2\left(\frac{8}{4}+\frac{21}{8}\right)n+O(1)=9.25n+O(1)$ turns or $2\left(\frac{10}{4}+\frac{28}{8}\right)n+O(1)=12n+O(1)$ crossings.

4.3 Lower Bounds

We show a lower bound for the optimal solution to each problem.

4.3.1 Number of Turns

As a starting point, note that every edge cell (cells in the first or last row or column) must contain a turn. This accounts for $4n-4$ turns. A simple argument, sketched in  A, improves this to a $4.25n-O(1)$ lower bound. Here we focus on the main result, a lower bound of $(6-\epsilon)n$ for any $\epsilon>0$. We start with some intermediate results.

We associate each cell in the board with a point $(i,j)$ in the plane, where $i$ is the row of the cell and $j$ is the column. An edge cell only has four moves available. We call the directions of these moves $D_{1},D_{2},D_{3},$ and $D_{4}$, in clockwise order. For an edge cell $c$, let $r_{i}(c)$, with $1\leq i\leq 4$, denote the ray starting at $c$ and in direction $D_{i}$. That is, the ray that passes through the cells reachable from $c$ by moving along $D_{i}$.

Let $a$ and $b$ be two cells along the left edge of the board, with $a$ above $b$. The discussion is symmetric for the other three edges. Given two intersecting rays $r$ and $r^{\prime}$, one starting from $a$ and one from $b$, let $S(r,r^{\prime})$ denote the set of cells in the region of the board bounded by $r$ and $r^{\prime}$: the set of cells below or on $r$ and above or on $r^{\prime}$. We define the crown of $a$ and $b$ as the following set of cells (Figure 13):

[TABLE]

We associate with each edge cell $c$ the two maximal sequences of moves without turns in the tour that have $c$ as an endpoint. We call them the legs of $c$. We say that the legs of $c$ begin at $c$ and end at their other endpoint. We say two legs of different edge cells collide if they end at the same cell. Let $C_{a,b}$ denote the set of edge cells along the left edge between $a$ and $b$ ($a$ and $b$ included). The following is easy to see.

Remark 1

Any collision between the legs of edge cells in $C_{a,b}$ happens inside $\mbox{crown}(a,b)$.

We say that a leg of an edge cell in $C_{a,b}$ escapes the crown of $a$ and $b$ if it ends outside the crown. We say an edge cell in $C_{a,b}$ is clean, with respect to $C_{a,b}$, if both of its legs escape.

Lemma 5

Let $m=|C_{a,b}|$ and $k$ be the number of clean cells in $C_{a,b}$. The number of turns inside $\mbox{crown}(a,b)$ is at least $m+(m-k)/2$.

Proof 5

Each of the $m$ edge cells is one turn. Each of the $m-k$ non-clean cells have a leg that ends in a turn inside the crown. This turn may be because it collided with the leg of another edge cell in the crown. Thus, there is at least one turn for each two non-clean edge cells.

Lemma 6

Let $a,b$ be two cells along the left edge of the board, with $a$ above $b$. There are at most 122 clean cells inside $\mbox{crown}(a,b)$.

Proof 6

First we show that there are at most 60 clean cells such that one of their legs goes in direction $D_{1}$. For the sake of contradiction, assume that there are at least 61. Then, there are two, $c$ and $d$, such that $c$ is $60r$ rows above $d$, for some $r\in\mathbb{N},r\geq 1$. The contradiction follows from the fact that the other leg of $c$, which goes along $D_{2},D_{3},$ or $D_{4}$, would collide with the leg of $b$ along $D_{1}$. This is because, for any $l\geq 1$, the leg of $b$ along $D_{1}$ collides with (Figure 13):

any leg along $D_{2}$ starting from a cell $3l$ rows above $b$,

• 2.

any leg along $D_{3}$ starting from a cell $5l$ rows above $b$, and

• 3.

any leg along $D_{4}$ starting from a cell $4l$ rows above $b$.

Since $60r$ is a multiple of $3,4,$ and $5$, no matter what direction the other leg of $c$ goes, it collides with the leg of $d$. As observed, this collision happens inside the crown. Thus, $c$ and $d$ are not clean. By a symmetric argument, there are at most 60 clean cells such that one of their legs goes in direction $D_{4}$.

Finally, note that there can only be two clean cells with legs in $D_{2}$ and $D_{3}$. By a similar argument, there cannot be two such cells at an even distance of each other; the leg along $D_{3}$ of the top one would collide with the leg along $D_{2}$ of the bottom one.

Corollary 1

Suppose that the crown of $a$ and $b$ has $m\geq 122$ edge cells. Then, there are at least $(m-122)/2$ turns inside the crown at non-edge cells.

Consider the iterative process depicted in Figure 15 defined over the unit square. The square is divided in four sectors along its main diagonals. Whereas earlier we used the term ‘crown’ to denote a set of cells, here we use it to denote the polygon with the shape of a crown. On the first step, a maximum-size crown is placed on each sector. On step $i>1$, we place $2^{i-1}$ more crowns in each sector. They are maximum-size crowns, subject to being disjoint from previous crowns, in each gap between previous crowns and between the crowns closest to the corners and the main diagonals.

Lemma 7

For any $\epsilon$ with $0<\epsilon<1$, there exists an $i\in\mathbb{N}$ such that at least $(1-\epsilon)$ of the boundary of the unit square is inside a crown after $i$ iterations of the process.

Proof 7

At each iteration $i>1$, a constant fraction larger than $0.36$ of the length on each side that is not in a crown is added to a new crown (Figure 15). This gives rise to a series $A_{i}$ for the fraction of the side inside crowns after $i$ iterations: $A_{1}=1/3$, $A_{i+1}>A_{i}+0.36(1-A_{i})$ for $i>1$; this series converges to $1$ (we do not prove that $A_{1}=1/3$, but this is inconsequential because the value of $A_{1}$ does not affect the convergence of the series).

Theorem 8** (Turns lower bound)**

For any constant $\epsilon>0$, there is a sufficiently large $n$ such that any knight’s tour on an $n\times n$ board has at least $(6-\epsilon)n$ turns.

Proof 8

We show a seemingly weaker form of the claim: that there is a sufficiently large $n$ such that any knight’s tour on an $n\times n$ board requires $(6-2\epsilon)n-C_{\epsilon}$ turns, where $C_{\epsilon}$ is a constant that depends on $\epsilon$ but not on $n$. This weaker form is in fact equivalent because, for sufficiently large $n$, $C_{\epsilon}<\epsilon n$, and hence $(6-2\epsilon)n-C_{\epsilon}>(6-3\epsilon)n$. Thus, the claim is equivalent up to a multiplicative factor in $\epsilon$, but note that it is a claim about arbitrarily small $\epsilon$, so it is not affected by a multiplicative factor loss.

Let $i$ be the smallest number of iterations of the iterative process in Figure 15 such that at least $(1-\epsilon)$ of the boundary of the unit square is inside crown shapes. The number $i$ exists by Lemma 7. Fix $S$ to be the corresponding set of crown shapes, and let $r=|S|$. Note that $r=4(2^{i}-1)$ is a constant that depends only on $\epsilon$. Now, consider a square board with the crown shapes in $S$ overlaid in top of them. Let the board length $n$ be such that the smallest crown in $S$ contains more than $122$ edge cells. Then, by Corollary 1, adding up the turns at non-edge cells over all the crowns in $S$, we get at least $4n(1-\epsilon)/2-61r$ turns. Adding the $4n-4$ turns at edge cells, we get that the total number of turns is at least $(6-2\epsilon)n-61r-4$. To complete the proof, set $C_{\epsilon}=61r+4$.

Corollary 2

Algorithm 1 achieves a $9.25/6+o(1)$ approximation on the minimum number of turns.

Proof 9

In an $n\times n$ board, let $ALG(n)$ denote the number of turns in the tour produced by Algorithm 1 (with the optimized heels from Section 4.2), and $OPT(n)$ denote the minimum number of turns. Let $\epsilon>0$ be an arbitrarily small constant. We show that an $n_{0}$ exists such that $\forall n\geq n_{0}$, $ALG(n)/OPT(n)<9.25/6+\epsilon$. As mentioned in Section 4.2, for any even $n\geq 16$, $ALG(n)<9.25n+c$ for some small constant $c$. In addition, by Theorem 8, for sufficiently large $n$, $OPT(n)>(6-\epsilon)n$. Thus, $ALG(n)/OPT(n)<(9.25n+c)/(n(6-\epsilon))$ Furthermore, for large enough $n$, $c/((6-\epsilon)n)<\epsilon/2$, and

[TABLE]

\qed

4.3.2 Number of Crossings

Theorem 9** (Crossings lower bound)**

Any knight’s tour on an $n\times n$ board has at least $4n-O(1)$ crossings.

Proof 10

Let $T$ be an arbitrary knight’s tour on an $n\times n$ board. We show that $T$ has $n-O(1)$ crossings involving knight moves incident to the cells along the left edge of the board. An analogous argument holds for the three other edges of the board, which add up to the desired bound.

We partition the edge cells along the left-most column into sets of three consecutive cells, which we call triplets (if $n$ is not a multiple of three, we ignore any remaining cells, as they only account for a constant number of crossings). Two triplets are adjacent if they contain adjacent cells. Each triplet has six associated knight moves in the tour $T$, two for each of its cells. We call the choice of moves the configuration of the triplet. Since there are $\binom{4}{2}=6$ choices of moves for each cell, there are $6^{3}=216$ possible configurations of each triplet (Figure 16, top).

Consider a weighted directed graph $G$ with a node for each of the $216$ possible triplet configurations and an edge from every node to every node, including a loop from each node to itself. The graph has weights on both vertices and edges. Given a node $v$, let $C(v)$ denote its associated configuration. The weight of $v$ is the number of crossings between moves in $C(v)$. The weight of each edge $v\rightarrow u$ is the number of crossings between moves in $C(v)$ and moves in $C(u)$ when $C(v)$ is adjacent and above $C(u)$ (Figure 16, bottom left and center). Triplets have the property that if two knight moves in $T$ with endpoints in edge cells cross, the edge cells containing the endpoints are either in the same triplet or in adjacent triplets. This is not true for groups of two edge cells instead of three (Figure 16, bottom right).

Each path in $G$ represents a choice of move configurations for a sequence of consecutive triplets. Thus, the sum of the weights of the vertices and edges in the path equals the total number of crossings among all of these moves. Since $G$ is finite, any sufficiently long path eventually repeats a vertex. Given a cycle $c$, let $w(c)$ be the sum of the weights of nodes and edges in $c$, divided by the length of $c$. Let $c^{*}$ be the cycle in $G$ minimizing $w$. Then, $w(c^{*})$ is a lower bound on the number of crossings per triplet along the edge.

The cycle minimizing $w$ can be found using Karp’s algorithm for finding the minimum mean weight cycle in directed graphs [39], which runs in $O(|V|\cdot|E|)$ time in a graph with vertex set $V$ and edge set $E$. However, this requires modifying the graph $G$, as Karp’s algorithm is not suitable for graphs that also have node weights. We transform $G$ into a directed graph $G^{\prime}$ with weights on only the edges and which preserves the optimal solution, as follows. We double each node $v$ in $G$ into two nodes $v_{in},v_{out}$ in $G^{\prime}$. We also add an edge $v_{in}\rightarrow v_{out}$ in $G^{\prime}$ with weight equal to the weight of $v$ in $G$. For each edge $v\rightarrow u$ in $G$, we add an edge $v_{out}\rightarrow u_{in}$ in $G^{\prime}$.

Using Karp’s algorithm, we found that, for $G$, $w(c^{*})=3$. Figure 17 shows an optimum cycle $c^{*}$, which in fact uses only one edge starting and ending at the same triplet configuration.

Since we only count crossings between moves incident to the first column, a question arises of whether the lower bound can be improved by considering configurations spanning more columns (e.g., the two or three leftmost columns). The answer is negative for any constant number of columns. Figure 17 shows that the edges can be extended to paths that cover any fixed number of columns away from the edge without increasing the number of crossings.

Combined with the upper bound, we obtain the following approximation ratio.

Corollary 3

Algorithm 1 achieves a $3+o(1)$ approximation on the minimum number of crossings.

5 Extensions

The idea of using formation moves to cover the board and junctions to close the tour is quite robust to variations of the problem. We show how this can be done in some of the most popular generalizations of the problem, formalized in the appropriate subsections: higher dimensions, boards with odd width and height and a missing corner, symmetric tours under 90 degree rotations, and tours for a different type of leaper, the $(1,4)$-leaper. In each case, there is a trivial lower bound on the number of turns of $\Omega(n)$, or $\Omega(n^{d-1})$ in the case of $d>2$ dimensions. This is because, in all these settings, the knight must turn after at most $n$ moves. In each case, our construction is within a constant factor of the minimum number of turns.

A variant that we do not consider are torus boards, where opposite edges are connected. This is because there already exists an algorithm that has $O(n)$ turns [34], and crossings are not straightforward to define in torus boards. The problem of finding tours with a small number of turns seems easier on a torus board, because one is not forced to make a turn when reaching an edge. Nonetheless, in a square $n\times n$ torus board, $\Omega(n)$ turns are still required, because making $n$ consecutive moves in the same direction brings the knight back to the starting position, so at least one turn is required for each $n$ visited cells. The tours for torus boards by Watkins and Hoenigman [34] match this lower bound up to constant factors, at least for some board dimensions (see the last section in [34]).

5.1 High-dimensional boards

We extend our technique to three and higher dimensions. In $d$ dimensions, a knight moves by $1$ and $2$ cells along any two dimensions, and leaves the remaining coordinates unchanged. A typical technique to extend a knight’s tour algorithm to three dimensions is the “layer-by-layer” approach [1, 10, 11]: a 2D tour is reused on each level of the 3D board, adding the minimal required modifications to connect them into a single tour. We also follow this approach. (Watkins and Yulan [40] consider a generalizations of knight moves where the third coordinate also has a positive offset, but this is not as common.)

We require one dimenson of the board to be even and at least $16$ and another dimension to be at least $12$. We assume, without loss of generality, that these are the first two dimensions. The other dimensions can have any size. Note that at least one dimension must be even, or no tour exists [12].

For illustration purposes, we start with the 3D case, and later extend it to the general case. The construction works as follows. The 2D construction from Algorithm 1 is reused at each level of the third dimension. However, there are only two actual junctions, one on the first level, of height 5, and one on the last level, which may have any of the four heights in Figure 4. Every other bottom-left or top-right corner is replaced by a sequence of formation moves. At every level except the last, the formation ends adjacent to the corner using one of the sequences of moves in Figure 18. We show sequences for 4 different junction heights, guaranteeing that one shape fits for any sizes of the first two dimensions. The levels are connected with a formation move one level up and two cells to the side, as in Figure 19. At every level except the first, the formation starts with the rightmost sequence of moves in Figure 18. A full example is illustrated in Figure 20.

Since the sequence of moves between junctions is more involved than in two dimensions, Lemma 1 may not hold. There is, however, an easy fix: if the entire sequence is not a single cycle, replace the first junction with one that has a vertical matching (second junction in Figure 4, rotated 180 degrees). This then makes a cycle.

If the number of dimensions is higher than three, simply observe that the same move used between levels can also be used to jump to the next dimension; instead of changing by $1$ the third coordinate, change the fourth. After the first such move, the formation will be at the “top” of the second 3D board, which can be traversed downwards. This can be repeated any number of times, and generalizes to any number of dimensions.

In a $n^{d}$ board, $\Omega(n^{d-1})$ turns are needed, because there are $n^{d}$ cells and a turn must be made after at most $n/2$ moves. Our construction has $O(n^{d-1})$ turns, as it consists of $n^{d-2}$ iterations of the 2D tour. Thus, it achieves a constant approximation ratio on the minimum number of turns. We do not know of any lower bound on the number of crossings in higher dimensions.

5.2 Odd boards

We show how to construct a tour for a 2D board with odd dimensions which visits every cell except a corner cell. This is used in the next section to construct a tour that is symmetric under $90^{\circ}$ rotations.

Let the board dimensions be $w\times h$, where $w>16$ and $h>12$ are both odd. First, we use Algorithm 1 to construct a $(w-1)\times h$ tour which is missing the leftmost column. Then, we extend our tour to cover this column, except the bottom cell, with the variations of our construction depicted in Figure 21. Since the sequence of moves between junctions is different than in the standard construction, Lemma 1 may not hold. Therefore, in the bottom-left junction, we might need to have a vertical or a horizontal matching. Figure 21 shows both options. For the top-left corner, recall that we use sequence $(3-h)\mbox{ mod }4$ in Figure 5. Here, the height $h$ is odd, so we only need adaptations for Sequences 2 and 0.

Figure 22 shows a complete tour with the adaptations from Figure 21.

5.3 90 Degree Symmetry

In this section, we show how to construct a symmetric tour under 90 degree rotations. We say a tour is symmetric under a given geometric operation if the tour looks the same when the operation is applied to the board.

As a side note, our construction is already nearly symmetric under $180^{\circ}$ rotations. For board dimensions such as $30\times 30$ (Figure 3) where opposite corners have the same shape, the only asymmetry is in the internal wiring of the junctions. However, the construction cannot easily be made fully symmetric. It follows from the argument in the proof of Lemma 1 that if the two non-junction corners are equal, the entire sequence of formation moves from one junction to the other is neutral. Thus, using the same junction in both corners, as required to have symmetry, would result in two disjoint cycles.

Symmetric tours under $90^{\circ}$ rotations exist only for square boards where the size $n=4k+2$ is a multiple of two but not a multiple of four [28]. Parberry [23] gives a construction for knight’s tours missing a corner cell and then shows how to combine four such tours into a single tour symmetric under $90^{\circ}$ rotations. We follow the same approach to obtain a symmetric tour with a number of turns and crossings linear on $n$, and thus constant approximation ratios.

In our construction from Section 5.2, cell $(1,1)$ is missing, and edge $e=\{(1,2),(3,1)\}$ is present. This suffices to construct a symmetric tour. Divide the $2n\times 2n$ board into four equal quadrants, each of which is now a square board with odd dimensions. Use the construction for odd boards to fill each quadrant, rotated so that the missing cell is in the center. Finally, connect all four tours as in Figure 23.

Figure 24 shows a complete tour obtained by connecting four rotated copies of the tour in Figure 22 using the transformation from Figure 23.

5.4 Giraffe’s tour

A giraffe is a leaper characterized by the move $(1,4)$ instead of $(1,2)$. Giraffe’s tours are known to exist on square boards of even size $n\geq 104$ [22] and on square boards of size $2n$ when $n$ is odd and bigger than $4$ [28]. Our result extends this to some rectangular sizes.

We adapt our techniques for finding giraffe’s tours with $O(w+h)$ turns and crossings, where $w$ and $h$ are the width and height of the board. We use a formation of $4\times 4$ giraffes. Figure 25 shows the formation moves, Figure 26 shows the analogous of a heel to be used to transition between diagonals, and Figure 27 shows the two junctions. Figure 28 shows how these elements are combined to cover the board.

We restrict our construction to rectangular boards where $w=32k+20$, for some $k\geq 1$, and $h=8l+14$, for some $l\geq 1$. Extending the results to more boards would require additional heel variations.

We start at the bottom-left junction as in the knight’s tour. We transition between diagonals along the bottom edge with a giraffe heel, and along the top edge with a flipped giraffe heel. We transition between diagonals along the left and right edges with four consecutive upward moves. The junction has width 20 and each heel has width 32, so there are $k$ heels along the bottom and top edges. The junction has height 11 and the tip of the heel has height 3, so there are $l$ sequences of four upward moves along each side (e.g., Figure 28).

It is easy to see that the construction visits every cell. As in the case of knight’s tours, for the result to be a valid giraffe’s tour there must be a single cycle instead of a set of disjoint cycles. Note that the matchings in the two junctions in Figure 27 form a cycle. Thus, if the formation reaches the top-right junction in the same matching as they left the bottom-left junction, the entire construction is a single cycle by an argument analogous to Theorem 2. Next, we argue that this is the case.

Let $H,F,$ and $U$ denote the sequences of formation moves in the heel, in the flipped heel, and the sequence of four upward moves, respectively. Let $T_{w,h}$ denote the entire sequence of moves from one junction to the other, where $w=32k+20$, for some $k\geq 1$, and $h=8l+14$, for some $l\geq 1$. Note that $T_{w,h}$ is a concatenation, in some order, of $H$ $k$ times, $F$ $k$ times, and $U$ $2l$ times (we can safely ignore diagonal moves, which do not change the coordinates of the giraffes within the formation). Let $M_{1}$ be the matching of the bottom-left junction. We want to argue that, after all the moves in $T_{w,h}$, the giraffes are still in matching $M_{1}$, that is, $T_{w,h}(M_{1})=M_{1}$, using the notation from Section 3.1.

We show that not only the giraffes arrive to the other junction in the same matching but, in fact, they arrive in the same coordinates in the formation as they started. First, note that $U$ has the effect of flipping column $1$ with $2$ and column $3$ with $4$ in the formation. Perhaps surprisingly, $H$ and $F$ have the same effect. This is tedious but can be checked for each giraffe (Figure 26 shows one in red). Therefore, $T_{w,h}$ is equivalent to $U$ $2(l+k)$ times in a row. Note that after eight consecutive upward moves, or $U$ twice, each giraffe ends where it started. Thus, this is true of the entire tour.

6 Conclusions

We have introduced two new metrics of “simplicity” for knight’s tours: the number of turns and the number of crossings. We provided an algorithm which is within a constant factor of the minimum for both metrics. In doing so, we found that, in an $n\times n$ board, the minimum number of turns and crossings is $O(n)$. Prior techniques such as divide-and-conquer necessarily result in $\Theta(n^{2})$ turns and crossings, so at the outset of this work it was unclear whether $o(n^{2})$ could be achieved at all.

The ideas of the algorithm, while simple, seem to be new in the literature, which is interesting considering the long history of the problem. Perhaps it was our initial optimization goal that led us in a new direction. The algorithm exhibits a number of positive traits. It is simple, efficient to compute, parallelizable, and amenable to generalizations (Section 5). We conclude with some open questions:

Our tours have $9.25n+O(1)$ turns and $12n+O(1)$ crossings, and we showed respective lower bounds of $(6-\epsilon)n$ and $4n-O(1)$. The main open question is closing or reducing these gaps, as there may still be room for improvement in both directions. We conjecture that the minimum number of turns is at least $8n$.

• 2.

Are there other properties of knight’s tours, besides turns and crossings, that might be interesting to optimize?

• 3.

Our method relies heavily on the topology of the “knight-move” graph. Thus, it is not applicable to general Hamiltonian cycle problems. Are there other graph classes with a similar enough structure that the ideas of formations and junctions can be useful?

Appendix A Simple Lower Bound for the Number of Turns

We show that any knight’s tour on a $n\times n$ board has at least $4.25n-O(1)$ turns. Consider the cells in one of the two central columns (does not matter which one), and in a row in the range $(n/4,3n/4)$. They are shown in red in Figure 29. These cells have the property that every maximal sequence of knight moves without turns through them reaches opposite facing edges. The maximal sequences of knight moves through the first and last red cells are shown in dashed lines. Because $n$ must be even, one of the two endpoints of each maximal sequence through a red cell is not an edge cell. It follows that each red cell is part of a sequence of knight’s moves that ends in a turn at a non-edge cell. Thus, there is at least one turn at a non-edge cell for each pair of red cells. Since there are $0.5n$ red cells, we get the mentioned lower bound.