(This is a consolidation, revision, and correction of several Mathematrec blog posts.)

## 8x8 board

On the Fediverse, @sam_hartburn@mathstodon.xyz asks :

What’s the shortest sequence of knight’s moves you can make on a chessboard such that the path is blocked at both ends (i.e. from either end of the sequence there are no squares you can move to that you haven’t already landed on)?

and provides a candidate path, one with 10 positions linked by 9 moves from the starting square to the ending one.

To make things clearer, we want a *path* consisting of an ordered list of *positions* separated by knight’s moves. Each position is to be visited only once. The *start* and *end*, or *terminal*, squares each have up to eight *neighbor* squares one knight’s move away, and all such neighbors must appear in the path.

It seems possible to come up with a proof that 9 moves is minimal; there’s at least the start of a proof in the replies to the linked post. It isn’t a simple proof, though. It does seem to be necessary to work one’s way through a number of different cases. Not a lot of fun. Instead I did what I often do with a problem like that: I wrote a Python script to do a relatively brain dead exhaustive search. Pick a starting square, add linked positions to the end until you can’t, then see if it’s also non-extendable at the starting end. Or stop when you have a path that’s already as long as the shortest non-extendable path already found. Count them all up after eliminating duplicates up to rotation, reflection, and direction reversal.

*Relatively* brain dead, not *completely* brain dead. It considers only 10 squares as starting points instead of all 64, for instance, because of symmetry.

(For some reason at first I tried extending the path in *both* directions until it couldn’t be extended at either end. That worked, but it had a lot of redundancy because, for instance, if you had (letters representing whatever moves) `fgh`

you’d check `fghi`

and then `efghi`

, and you’d also check `efgh`

and then `efghi`

. Extending only at one end and then checking non-extendability at the other turns out to be *much* faster.)

Maybe a smarter approach would be to take all possible combinations of start and end positions, add their neighbors, observe that you can get from some of these positions to some of the others via a single move while other pairs require 2, 3, or more moves, and then search for the shortest path through all the positions starting at one terminal and ending at the other. But efficient algorithms to do that seem to be hard.

So do I have a bug free script that generates all non-extendable paths? Maybe! Or maybe not. I don’t see any problems, but there could be some. You can find the script at https://gitlab.com/rsholmes/nep .

If it’s right, I find 74 paths with 9 moves, and none with fewer. @Elmusfire@mathstodon.xyz used a different method and posted their complete set of solutions, and it’s larger than my allegedly complete set, but on close inspection they didn’t get rid of all the duplicates. Eliminating them might put us in agreement.

The *longest* possible non-extendable path is 63 moves — it’s an old and well known result that a knight can visit every square on the board without repeating.

## n×n boards

Of course it’s easy enough to have the script consider boards of other sizes. I checked square boards up through 12×12, determining the minimum number of moves in a non-extendable path and the number of such paths. As @Elmusfire points out, one of the 8×8 solutions fits within a 4×4 square, meaning that for any finite board of size 4×4 or larger, the minimum length non-extendable path is no longer than 9 moves. But for some boards, shorter paths exist. On a 4×4 board, for instance, there are 2 paths with 6 moves:

Likewise there are shorter paths on the 5×5, 6×6, and 7×7 boards. But I was surprised to discover there are shorter paths on the 9×9 board too! Since consecutive squares in a knight’s path alternate colors, a path from one corner (which has only two neighbors, so is a favorable place for a terminal) to an adjacent corner requires an even number of moves for odd-order squares and an odd number for even-order squares. On the 8×8 board no 7-move path is long enough to link two adjacent corners and cover all four neighbors, so 9 moves are needed. Diagonally opposite corners are the same color, so an 8-move path might seem possible, but it isn’t — the distance is just a bit too far. So it makes sense 9 moves is the minimum. On the 9×9 board, though, you need an even number of moves to get between any two corners, and there are two 8-move paths that do link adjacent corners and include the four neighbors.

For 11×11 and 12×12 there are no shorter paths. All the 9-move paths are close to one corner, not making use of the opposite edges, so both boards have the same set of solutions, and presumably so do all boards larger than 11×11, square or not. The 8×8 and 10×10 solutions are just the 11×11 solutions plus 5 and 3 additional solutions, respectively, that go from corner to corner.

A summary of my findings:

Board size | Min # moves | # solutions |
---|---|---|

1×1 | 0 | 1 |

2×2 | 0 | 1 |

3×3 | 0 | 1 |

4×4 | 6 | 2 |

5×5 | 6 | 3 |

6×6 | 7 | 5 |

7×7 | 8 | 6 |

8×8 | 9 | 74 |

9×9 | 8 | 2 |

10×10 | 9 | 72 |

11×11 | 9 | 69 |

12×12 | 9 | 69 |

The solutions are spelled out at the end of this article.

## ∞×∞ boards

@Elmusfire also raises the question: What is the shortest non-extendable path on an *infinite* board? One that extends infinitely in all directions, with no edges?

You’d have to have a path that hits a total of at least 18 squares: The start and end squares, and the eight neighbors of each — except that with some positions of the terminal squares, some of these 18 squares coincide.

You probably want the terminal squares to be opposite colors; otherwise all the neighbor squares are the same color, and a path linking them has to hit almost equally many non-neighbor squares of opposite colors in between.

Suppose, for instance, the terminal squares are adjacent. Then the squares that have to be visited are these:

We can partition the eight neighbors into six sets of neighbors all linked by single moves, with no neighbor linked by a single move to any neighbor not in the same set:

Two sets of six neighbors are linked by single moves into a pair of cycles:

The four remaining neighbors need two or more moves to link to any other neighbor, so we put each in its own set.

I’ll call these sets *clusters*. Reaching all the neighbors in a cluster obviously requires, at minimum, a number of moves equal to the number of neighbors in that cluster. (If there isn’t a Hamiltonian path for a cluster then more moves are needed, but obviously that isn’t the case here.) But getting to the first neighbor in a cluster from a neighbor outside that cluster requires at least one more move. So if there are $l n$ neighbors in $l c$ clusters, you need at least $l n+c$ moves to reach them all — except that one cluster can be reached from the start position, so you can subtract 1. On the other hand, you need 1 more move to get to the end position. So a lower bound on the minimal non-extendable path length is just $l n+c$.

But as mentioned above, going between two opposite color squares requires an odd number of moves; going between the same color squares requires an even number of moves. So if $l n+c \ne d \mod 2$, where $l d$ is the Manhattan distance between the start and end positions, the lower bound becomes $l n+c+1$.

On the infinite board *with adjacent start and end positions*, $l n=16$ and $l c=6$, and an odd number of moves is required, so the lower bound is $l n+c+1=23$ moves.

But are there such paths? Yes; here is one:

What about other terminal position offsets? Here they are separated by a knight’s move. There are 14 neighbors and 8 clusters: six 2-cycles and two singletons.

Here again we get 23 for the minimum number of moves, and again such a path is possible:

You can examine the other possible offsets between the start and end positions. You’ll find all of them lead to lower bounds larger than 23.

Therefore, considering *all* start and end positions, the minimal length non-extendable path on the infinite plane is 23 moves.∎

## Tori

How about non-extendable paths on toroidal boards?

It was easy to make my script do that. All it needed was to redefine a move to wrap around at the “edge” of the board. Er… except with a torus, in addition to checking for duplicate solutions under rotations, reflections, and direction reversals, you also have to check for translations. And there’s no point in trying different starting squares. OK, still pretty easy…

What’s not so easy is *running* the modified script, because it can take a lot longer. The combinatorics get very bad for any torus bigger than 4×4. See below.

But I didn’t need to run the search script to find the following path on the 5×5, and to prove that at 13 moves, it is the shortest possible length:

Proof: For terminal positions a knight’s move apart, one neighbor of each terminal coincides with the other terminal, and three other neighbors of one terminal coincide with neighbors of the other, so there are only $l n = 16-2-3 = 11$ neighbor positions. There are $l c=2$ clusters, of 3 and 8 neighbors respectively. Then the minimal path for this offset is $l n+c = 13$ moves.

For terminal positions at any other separation, only two neighbors of one terminal coincide with neighbors of the other, so $l n = 14$. In each case all 14 are in a cluster, so $l c=1$; there might be a path of 15 moves, but none shorter.∎

The same approach can apply to other tori.

For the 6×6 torus it’s a little complicated. The optimum offset appears to be a knight’s move: There are 14 neighbors all in a single cluster, for a 15 move minimum. But on examination the cluster does not have a Hamiltonian path, so extra moves are needed. I think the minimal path with this offset is 19 moves.

Meanwhile the apparent second best offset is (3, 3). With this offset *every* neighbor of the start position is also a neighbor of the end position and vice versa! There are therefore only 8 distinct neighbors. Each is a singleton cluster so the lower limit on the path length with that offset is 16. And in fact you can link all 8 neighbors using 7 intermediate positions, ending up with a 16-move path:

For 7×7, the optimum offset turns out to be (3, 2). That gives 15 neighbors in 4 clusters, for a lower limit of 19 moves… and behold, that’s possible.

Here’s 8×8. We’re back to a knight’s move offset. 14 neighbors and 5 clusters, so a 19 move minimum again, but one cluster isn’t Hamiltonian so an extra move is needed, and then another by a parity coloring argument. That means 21 moves is minimal, and here is one example:

9×9 is interesting. There are three optimal offsets. (4, 0) gives 14 neighbors and 8 clusters (two 4-clusters and 6 singletons), summing to 22 moves. The other two are (1, 0) and (2, 1), resulting in the same neighbors and clusters as in the infinite plane case. They also sum to 22 moves.

On the infinite plane, coloring says there must be an odd number of moves, so 22 bumps up to 23. However, 9×9 has odd circumferences, so cannot be globally 2-colored; the coloring argument doesn’t work. In fact, by wrapping around the torus, you *can* connect everything up with 22 moves. Here’s a path using the (4, 0) offset:

On the 10×10 torus the best offset is (5, 0). 16 neighbors in 4 clusters for a sum of 20, but by coloring the number of moves must be odd, hence 21, and that is possible:

For a torus 11×11 or larger, the situation is similar to 9×9, though with only (1,0) and (2,1) offsets being optimal. Even sizes are subject to the same coloring argument as the infinite plane, so the shortest paths are 23 moves. Odd sizes do not have global 2-colorings, but unlike in the 9×9 case, I think 11×11 and larger allow local 2-coloring in a large enough area to make the same argument apply. Basically I don’t think you can connect neighbors by wrapping around the torus in few enough moves to get an advantage. So I’m fairly sure 23 moves is the minimum for all tori 11×11 or larger.

Getting back to exhaustive search results, the 2×2 torus is pretty trivial, but less so than the 2×2 flat board; the shortest path is 3 moves and is unique. For 3×3 the minimum is 7 moves and there are 4 such paths. For 4×4, 9 moves and 2 paths. These are enumerated at the end of this article.

For larger toruses, things get difficult.

On a flat board, some squares, the ones on and near the corners and on the edges, have only 2 or 3 or 4 neighbors. On the 3×3 and 4×4 toruses, due to wraparound, a knight’s move in one direction can get you to the same square as one in a different direction, so *all* squares have only 4 neighbors. It takes only about 0.1 seconds to analyze those. But on the 5×5 torus there are no corners or edges, and a single move doesn’t wrap around, so every square has *8* neighbors, and the paths are longer. A crude sense of how much worse the combinatorics are is to observe there would be 8 choices for 13 moves versus 4 choices for 9 moves in the absence of blocking, leading to a factor of $l 8^{13}/4^9 =$ 2,097,152.

For the 5×5 torus, my script found 2448 solutions, of length 13 moves. (Told you.) It took about 10.5 hours. I’m not including them here, though I have them stored if anyone needs them. I’m not doing the 6×6.

It appears we have these minimum paths:

Torus size | Min # moves | # solutions |
---|---|---|

1×1 | 0 | 1 |

2×2 | 3 | 1 |

3×3 | 7 | 4 |

4×4 | 9 | 2 |

5×5 | 13 | 2448 |

6×6 | 16 | ? |

7×7 | 19 | ? |

8×8 | 21 | ? |

9×9 | 22 | ? |

10×10 | 21 | ? |

11×11+ | 23 | ? |

## Solutions

Here are paths and numbers of solutions flat boards from 4×4 to 11×11, toroidal boards from 2×2 to 11×11, and infinite boards.

### Flat boards

4×4: 2 solutions, 6 moves

[[0, 0], [1, 2], [3, 1], [1, 0], [0, 2], [2, 1], [3, 3]]

[[0, 0], [1, 2], [2, 0], [0, 1], [1, 3], [2, 1], [3, 3]]

5×5: 3 solutions, 6 moves

[[0, 0], [1, 2], [2, 4], [3, 2], [1, 3], [2, 1], [4, 0]]

[[0, 0], [1, 2], [2, 0], [3, 2], [1, 3], [2, 1], [4, 0]]

[[0, 0], [1, 2], [3, 3], [2, 1], [1, 3], [3, 2], [4, 0]]

6×6: 5 solutions, 7 moves

[[0, 0], [1, 2], [2, 4], [3, 2], [4, 0], [2, 1], [1, 3], [0, 5]]

[[0, 0], [1, 2], [3, 3], [2, 1], [1, 3], [3, 2], [2, 4], [0, 5]]

[[0, 0], [1, 2], [3, 3], [2, 1], [4, 2], [2, 3], [3, 5], [5, 4]]

[[0, 0], [1, 2], [3, 1], [1, 0], [0, 2], [2, 1], [4, 2], [5, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [0, 2], [2, 1], [4, 2], [5, 0]]

7×7: 6 solutions, 8 moves

[[0, 0], [1, 2], [0, 4], [2, 5], [1, 3], [2, 1], [0, 2], [1, 4], [0, 6]]

[[0, 0], [1, 2], [0, 4], [2, 5], [1, 3], [2, 1], [3, 3], [1, 4], [0, 6]]

[[0, 0], [1, 2], [0, 4], [2, 5], [3, 3], [2, 1], [0, 2], [1, 4], [0, 6]]

[[0, 0], [1, 2], [2, 4], [4, 5], [3, 3], [2, 1], [4, 2], [5, 4], [6, 6]]

[[0, 0], [1, 2], [3, 1], [5, 2], [4, 0], [2, 1], [3, 3], [4, 1], [6, 0]]

[[0, 0], [1, 2], [2, 0], [4, 1], [3, 3], [2, 1], [4, 0], [5, 2], [6, 0]]

8×8: 74 solutions, 9 moves

Same as 11×11 but adding:

[[0, 0], [1, 2], [3, 3], [2, 1], [0, 2], [1, 4], [2, 6], [3, 4], [1, 5], [0, 7]]

[[0, 0], [1, 2], [3, 3], [2, 1], [0, 2], [2, 3], [1, 5], [3, 4], [2, 6], [0, 7]]

[[0, 0], [1, 2], [3, 3], [2, 1], [1, 3], [3, 2], [5, 1], [4, 3], [6, 2], [7, 0]]

[[0, 0], [1, 2], [3, 3], [2, 1], [4, 0], [3, 2], [5, 1], [4, 3], [6, 2], [7, 0]]

[[0, 0], [1, 2], [3, 3], [2, 1], [4, 2], [2, 3], [1, 5], [3, 4], [2, 6], [0, 7]]

9×9: 2 solutions, 8 moves

[[0, 0], [1, 2], [3, 3], [2, 1], [4, 2], [6, 1], [5, 3], [7, 2], [8, 0]]

[[0, 0], [1, 2], [3, 3], [2, 1], [4, 0], [6, 1], [5, 3], [7, 2], [8, 0]]

10×10: 72 solutions, 9 moves

Same as 11×11 but adding:

[[0, 0], [1, 2], [3, 3], [2, 1], [1, 3], [0, 5], [1, 7], [3, 6], [2, 8], [0, 9]]

[[0, 0], [1, 2], [3, 3], [2, 1], [1, 3], [2, 5], [1, 7], [3, 6], [2, 8], [0, 9]]

[[0, 0], [1, 2], [3, 3], [2, 1], [4, 0], [5, 2], [7, 1], [6, 3], [8, 2], [9, 0]]

11×11 (and all larger finite boards): 69 solutions, 9 moves

[[0, 0], [1, 2], [3, 3], [2, 1], [0, 2], [1, 4], [2, 2], [4, 3], [3, 1], [1, 0]]

[[0, 0], [1, 2], [3, 3], [2, 1], [0, 2], [2, 3], [3, 1], [4, 3], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 3], [2, 1], [1, 3], [3, 4], [2, 2], [4, 1], [2, 0], [0, 1]]

[[0, 0], [1, 2], [3, 3], [2, 1], [1, 3], [3, 2], [2, 0], [4, 1], [2, 2], [0, 1]]

[[0, 1], [2, 2], [4, 1], [3, 3], [1, 2], [0, 0], [2, 1], [1, 3], [3, 2], [2, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [0, 2], [2, 1], [1, 3], [0, 1], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [0, 2], [2, 1], [1, 3], [3, 4], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [0, 2], [2, 1], [3, 3], [1, 4], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [0, 2], [2, 1], [3, 3], [4, 1], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [0, 2], [2, 1], [4, 2], [3, 0], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [0, 2], [2, 1], [4, 2], [3, 4], [2, 2], [1, 0]]

[[0, 1], [2, 2], [4, 1], [5, 3], [3, 2], [1, 3], [2, 1], [0, 0], [1, 2], [2, 0]]

[[0, 0], [1, 2], [3, 1], [2, 3], [4, 2], [2, 1], [0, 2], [1, 4], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [4, 3], [2, 2], [0, 1], [1, 3], [2, 1], [0, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [4, 3], [2, 2], [1, 4], [3, 3], [2, 1], [0, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [4, 3], [2, 2], [3, 4], [1, 3], [2, 1], [0, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [4, 3], [2, 2], [3, 4], [4, 2], [2, 1], [0, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [4, 3], [2, 2], [4, 1], [3, 3], [2, 1], [0, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [4, 3], [2, 2], [3, 0], [4, 2], [2, 1], [0, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [5, 2], [4, 0], [2, 1], [0, 2], [1, 4], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [5, 2], [3, 3], [2, 1], [0, 2], [1, 4], [2, 2], [1, 0]]

[[0, 0], [1, 2], [3, 1], [5, 0], [4, 2], [2, 1], [0, 2], [1, 4], [2, 2], [1, 0]]

[[0, 0], [1, 2], [2, 0], [3, 2], [1, 3], [2, 1], [0, 2], [1, 4], [2, 2], [0, 1]]

[[0, 0], [1, 2], [2, 0], [3, 2], [1, 3], [2, 1], [0, 2], [1, 0], [2, 2], [0, 1]]

[[0, 0], [1, 2], [2, 0], [3, 2], [1, 3], [2, 1], [3, 3], [1, 4], [2, 2], [0, 1]]

[[0, 0], [1, 2], [2, 0], [3, 2], [1, 3], [2, 1], [3, 3], [4, 1], [2, 2], [0, 1]]

[[0, 0], [1, 2], [2, 0], [3, 2], [1, 3], [2, 1], [4, 2], [3, 0], [2, 2], [0, 1]]

[[0, 0], [1, 2], [2, 0], [3, 2], [1, 3], [2, 1], [4, 2], [3, 4], [2, 2], [0, 1]]

[[0, 0], [1, 2], [2, 0], [3, 2], [4, 0], [2, 1], [1, 3], [3, 4], [2, 2], [0, 1]]

[[0, 0], [1, 2], [2, 0], [4, 1], [2, 2], [1, 0], [0, 2], [2, 1], [1, 3], [0, 1]]

[[0, 0], [1, 2], [2, 0], [4, 1], [2, 2], [1, 4], [0, 2], [2, 1], [1, 3], [0, 1]]

[[0, 0], [1, 2], [2, 0], [4, 1], [2, 2], [1, 4], [3, 3], [2, 1], [1, 3], [0, 1]]

[[0, 0], [1, 2], [2, 0], [4, 1], [2, 2], [3, 4], [4, 2], [2, 1], [1, 3], [0, 1]]

[[0, 0], [1, 2], [2, 0], [4, 1], [2, 2], [3, 0], [4, 2], [2, 1], [1, 3], [0, 1]]

[[0, 0], [1, 2], [2, 0], [4, 1], [3, 3], [2, 1], [1, 3], [3, 4], [2, 2], [0, 1]]

[[0, 1], [2, 2], [4, 1], [5, 3], [3, 2], [1, 3], [2, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [5, 3], [3, 2], [1, 3], [2, 5], [0, 4], [1, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [5, 3], [3, 2], [1, 3], [2, 5], [3, 3], [1, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [5, 3], [3, 2], [1, 3], [0, 5], [2, 4], [1, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [5, 3], [3, 4], [1, 3], [3, 2], [2, 4], [1, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [3, 3], [1, 2], [2, 4], [0, 5], [1, 3], [3, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [3, 3], [1, 2], [0, 4], [2, 5], [1, 3], [3, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [3, 3], [2, 1], [1, 3], [3, 2], [2, 4], [1, 2], [2, 0]]

[[0, 1], [2, 2], [4, 1], [3, 3], [2, 5], [1, 3], [3, 2], [2, 4], [1, 2], [2, 0]]

[[0, 1], [2, 2], [3, 4], [1, 3], [3, 2], [5, 3], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [2, 2], [3, 4], [1, 3], [3, 2], [2, 4], [1, 2], [3, 3], [4, 1], [2, 0]]

[[0, 1], [1, 3], [3, 2], [2, 4], [1, 2], [3, 1], [1, 0], [2, 2], [4, 1], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 3], [4, 1], [2, 2], [1, 0], [3, 1], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [1, 1], [3, 0], [2, 2], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [1, 1], [0, 3], [2, 2], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 1], [3, 0], [2, 2], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 1], [4, 3], [2, 2], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 3], [4, 1], [2, 2], [4, 3], [3, 1], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 3], [4, 1], [2, 2], [4, 3], [2, 4], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 3], [4, 1], [2, 2], [1, 4], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 3], [4, 1], [2, 2], [0, 3], [2, 4], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [5, 3], [3, 4], [2, 2], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [2, 4], [0, 3], [2, 2], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 2], [2, 4], [1, 2], [3, 1], [4, 3], [2, 2], [4, 1], [2, 0]]

[[0, 1], [1, 3], [3, 2], [2, 4], [1, 2], [3, 3], [1, 4], [2, 2], [4, 1], [2, 0]]

[[0, 1], [1, 3], [3, 2], [2, 4], [4, 3], [2, 2], [4, 1], [3, 3], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 4], [2, 2], [4, 1], [5, 3], [3, 2], [2, 4], [1, 2], [2, 0]]

[[0, 1], [1, 3], [3, 4], [2, 2], [4, 1], [3, 3], [1, 2], [2, 4], [3, 2], [2, 0]]

[[0, 3], [2, 4], [3, 2], [4, 4], [2, 3], [1, 5], [3, 4], [2, 2], [3, 0], [1, 1]]

[[0, 3], [1, 5], [2, 3], [4, 4], [3, 2], [2, 4], [4, 3], [2, 2], [3, 0], [1, 1]]

[[0, 3], [2, 2], [3, 0], [5, 1], [3, 2], [2, 4], [3, 6], [1, 5], [2, 3], [1, 1]]

[[0, 3], [2, 2], [3, 0], [4, 2], [2, 3], [1, 5], [3, 6], [2, 4], [3, 2], [1, 1]]

[[0, 3], [2, 4], [3, 2], [5, 1], [3, 0], [2, 2], [3, 4], [1, 5], [2, 3], [1, 1]]

[[0, 3], [1, 5], [2, 3], [4, 2], [3, 0], [2, 2], [4, 3], [2, 4], [3, 2], [1, 1]]

(Only first 7 rows and columns shown, the rest are empty.)

### Toroidal boards

2×2: 1 solution, 3 moves

[[0, 0], [0, 1], [1, 1], [1, 0]]

3×3: 4 solutions, 7 moves

[[0, 0], [1, 1], [2, 2], [0, 1], [1, 2], [2, 1], [0, 2], [1, 0]]

[[0, 0], [1, 1], [0, 2], [2, 1], [1, 2], [0, 1], [2, 2], [1, 0]]

[[0, 0], [1, 1], [0, 2], [2, 1], [1, 2], [0, 1], [1, 0], [2, 2]]

[[0, 0], [1, 1], [0, 2], [1, 0], [2, 1], [1, 2], [0, 1], [2, 2]]

4×4: 2 solutions, 9 moves

[[0, 0], [1, 2], [2, 0], [0, 1], [1, 3], [2, 1], [0, 2], [2, 3], [1, 1], [3, 2]]

[[0, 0], [1, 2], [3, 1], [1, 0], [0, 2], [2, 1], [1, 3], [3, 2], [1, 1], [2, 3]]

5×5: a 13-move solution

[[2, 2], [1, 4], [4, 3], [3, 0], [0, 1], [2, 0], [3, 3], [0, 4], [1, 2], [3, 1], [1, 0], [3, 4], [0, 3], [4, 2]]

6×6: a 16-move solution

[[0, 0], [4, 2], [5, 4], [3, 5], [1, 4], [2, 2], [4, 1], [5, 3], [4, 5], [2, 4], [1, 2], [3, 1], [5, 2], [4, 4], [2, 5], [3, 3]]

7×7: a 19-move solution

[[0, 0], [5, 6], [4, 4], [6, 5], [5, 3], [0, 2], [5, 1], [4, 3], [2, 4], [1, 2], [2, 0], [1, 5], [3, 4], [2, 6], [1, 1], [6, 2], [1, 3], [2, 1], [4, 0], [3, 2]]

8×8: a 21-move solution

[[0, 0], [2, 7], [4, 0], [6, 7], [5, 5], [7, 6], [1, 7], [0, 5], [1, 3], [7, 2], [0, 4], [1, 2], [3, 3], [4, 5], [3, 7], [1, 6], [7, 5], [6, 3], [4, 2], [6, 1], [0, 2], [2, 1]]

9×9: a 22-move solution__ [[8, 4], [7, 6], [5, 5], [6, 3], [4, 2], [5, 4], [4, 6], [6, 5], [5, 3], [7, 2], [8, 0], [0, 2], [2, 1], [1, 3], [0, 1], [2, 2], [1, 4], [0, 6], [2, 7], [1, 5], [0, 7], [2, 6], [3, 4]]

10×10: a 21-move solution

[[9, 4], [0, 2], [2, 3], [1, 5], [3, 6], [2, 4], [3, 2], [1, 3], [2, 5], [0, 6], [2, 7], [3, 5], [5, 6], [7, 5], [6, 3], [8, 2], [7, 4], [8, 6], [6, 5], [7, 3], [5, 2], [4, 4]]

11×11: same as infinite board

### Infinite board

∞×∞: a couple of 23-move solutions

[[3, 4], [1, 3], [0, 5], [2, 6], [4, 5], [5, 3], [3, 2], [2, 0], [1, 2], [0, 4], [1, 6], [3, 5], [2, 7], [4, 6], [5, 4], [4, 2], [3, 0], [2, 2], [0, 3], [1, 5], [3, 6], [5, 5], [4, 3], [2, 4]]

[[5, 4], [7, 3], [6, 5], [4, 6], [2, 7], [3, 9], [4, 7], [6, 6], [8, 7], [7, 5], [5, 6], [6, 4], [4, 5], [3, 3], [1, 4], [0, 2], [2, 3], [4, 2], [5, 0], [6, 2], [4, 3], [2, 4], [1, 6], [3, 5]]