Posts from http://www.speedsolving.com/forum/showthread.php?34968, in January 2012.

I didn't know where else to put this, but I'm sure some people here will
find this interesting. Hopefully this is actually new and not an
obvious thing that I somehow couldn't find on Google.

So, you're probably all familiar with the Tower of Hanoi problem. You have three pegs, and n disks of different sizes on one of the pegs, arranged with the largest
disks on the bottom. The goal is to move all the disks to a different
peg; the rules are that (a) you can only move one disk at a time (from
one peg to another peg), and (b) you can't place a disk on top of a
smaller disk. The problem is not too difficult to solve if you are just
trying to finish it, but the mathematically interesting thing is that it
requires O(2^n) moves - roughly doubling for every new disk you add. The reason for this is that, to move n disks, you must first move the smallest n-1 disks to another peg, then move the biggest disk, and finally move the rest of the disks a second time.

For a while I've been casually trying to think of a way to extend this to create puzzles which require O(k^n) moves (for n disks, and for a k as large as we want). I think I've got an idea which will let us do
this. Here is a rough picture of the idea, for a small case:

So, here's what's going on here. Choose some number j. Instead of 3 pegs you have 2j+1 pegs, and instead of disks that cover one peg, they cover j adjacent pegs. The trick is that the only way to move a disk is to move all of the smaller disks to j of the other j+1 pegs - and, even then, this will only allow you to move the remaining disk clockwise or counterclockwise by one peg.

Figuring out the number of moves is a little trickier than in the normal
3-peg version, but at least we know that we can only move the biggest
disk if all of the other disks are in a pile. To move a pile of n disks by one space, we need to (1) move n-1 disks by j spaces, (2) move the biggest disk, and then (3) move n-1 disks by j spaces again. To move a pile of n disks by k spaces, though, we need to (1) move n-1 disks by j spaces, (2) repeat (move the biggest disk, then move n-1 disks one space) k-1 times, (3) move the biggest disk one last time, and then (4) move n-1 disks by j spaces again to finish. Only moves of 1 and j spaces seem to be important here, so if we write those as and the recursion looks like this:

Or, just in terms of the 1-move numbers:

Anyway, it looks like the k constant (the number for which grows like ) works out to . So that's pretty interesting, and we can definitely get k as large as we like by choosing a sufficiently high j. In fact, we can set k to be any even integer: for instance, let j=41, and then the sequence grows as fast as .
Of course, boards with 83 pegs and disks with 41 holes are not
particularly nice to play with, but seeing as the 5-disk puzzle takes
14,751 moves to just move the disks one space over, I don't think a lot
of people would complain.

Incidentally, if you don't like the idea of disks spanning multiple
pegs, you can get the same effect by using 1-peg disks and adding the
rule that you cannot put a disk onto a peg if a smaller disk is on that
peg __or one of the next j-1 pegs in either direction__.

Alright guys, I made a sim. Try it here:

http://mzrg.com/js/hanoi/

>Very interesting, didn't read all of it though. Just curious, how did you come up with this idea?

I basically was thinking about how to expand the problem while keeping the restricted feel of the original one (only really one way to move stuff around) and I randomly thought of the idea of disks that would cover more than one peg, and of just barely having enough pegs to move those disks around. I initially had a wrong idea of how the math would turn out (since I didn't realize you could take shortcuts when moving a group of disks more than one space at a time) but the idea turned out to be what I wanted anyway.

PS: Wolfram Alpha gives the following closed form for :

## No comments:

Post a Comment