河内塔(Tower of Hanoi)是一个很谜的数学游戏,它是由三根杆子(Rod)和一个以上大小不同的盘片(Disk)所组成的。在游戏的一开始,这些盘片按照底大顶小的顺序叠在一起,由三根杆子中的其中一根串着。玩家每次可以移动一个盘片到其它的杆子上,但是不能将比较大的盘片叠在比较小的盘片上。当玩家把所有盘片都串到指定的杆子,游戏就结束了。
如上图所示,就是一个三碟的河内塔游戏。习惯上会把最左边的杆子称作「A」,是起点。中间的杆子称作「B」。右边的杆子称作「C」,是终点。
所以要完成上面的这个河内塔,就要把左边的三个盘片移动到右边。移动方式如下视频:
通常河内塔的游戏至少会有三个盘片(如果盘片只有两个以下那还玩个毛),盘片愈多难度愈高。如果您从来没玩过的话,就算看了上面的视频,应该也还是不知道要怎么移,或者不知道为什么要那样移动。
其实要完成一个河内塔游戏,盘片的移动方式不只有一种而已。如果我们把视频中的盘片,以黄色、红色、蓝色的顺序来表示其所在的杆子,一开始,我们可以用 AAA 来表示(黄色、红色、蓝色都在 A 杆子)。下一步,我们只能够移动黄色盘片到 B 杆子或是 C 杆子,所以可以标示为 BAA(黄色在 B 杆子,红色、蓝色在 A 杆子)或是 CAA(黄色在 C 杆子,红色、蓝色在 A 杆子)。再下一步,可以移动黄色或红色盘片到空的杆子上,所以如果这一步是 BAA 的话,下一步就是 BCA 或 CAA;如果这一步是 CAA 的话,下一步就是 CBA 或 BAA。
让我们依此类推,继续用这样的标示法来把所有的组合都找出来,会得到如下的结果:
AAA
/ \
BAA-CAA
/ \
BCA CBA
/ \ / \
CCA-ACA-ABA-BBA
/ \
CCB BBC
/ \ / \
ACB-BCB CBC-ABC
/ \ / \
ABB BAB CAC ACC
/ \ / \ / \ / \
BBB-CBB CAB-AAB-AAC-BAC-BCC-CCC
如上,我们把三碟的河内塔所有的移动方式都画成图(Graph)了,每条边所连接的两个节点表示这两个节点「只差了一步」。AAA 作为我们的起点,CCC 作为我们的终点,从上图可以快速地看出起点到终点的最短路径为 7。换句话说,三碟的河内塔,最少只要移动 7 步就可以完成。
再仔细看一次上面的视频,可以发现视频中的盘片移动方式正是最短路线。而且我们还可以注意到一个点,那就是我们在把三个盘片移动到 C 杆子前,有先把两个盘片移动到 B 杆子;而在两个盘片移动到中间前,有先把一个盘片移动到 C 杆子。也就是说,若我们要移动 #{{n}}# 个盘片到某指定的杆子上,就要先把 #{{n - 1}}# 个盘片移动到旁边的杆子上,此时最大的盘片就可以被移动到指定的杆子上,最后再把旁边杆子上的 #{{n - 1}}# 个盘片移来最大的盘片上,#{{n}}# 个盘片就都在指定的杆子上啦。
简而言之,我们找出的「以最短步数解决河内塔问题的算法」就是:
步骤一:移动 A 杆子上的 #{{n - 1}}# 个盘片到 B 杆子上。
步骤二:移动 A 杆子剩下的一个盘片到 C 杆子上。
步骤三:移动 B 杆子上的所有(#{{n - 1}}# 个)盘片到 C 杆子上。
如何?有没感觉像是在讲屁话?可是电脑真的可以这样做!
实际写程序就知道了。首先创建一个 hanoi 函数,让它可以透过参数输入盘片的数量 #{{n}}#、起始的杆子、结束的杆子和暂存的杆子。在程序一开始先去判断盘片的数量是否为 1,如果是的话就把盘片从起始的杆子移动到结束的杆子。我们不必真的创建出盘片的对象或是数值,因为河内塔的重点是在找盘片的移动方式。例如:A 移到 B→A 移到 C→B 移到 C。
可以先写出以下的代码:
pub fn hanoi(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
if disk_count == 1 {
println!("Move a disk from {rod_from} to {rod_to}.");
}
}
public static void hanoi(final int disk_count, final char rod_from, final char rod_temp, final char rod_to) {
if (disk_count == 1) {
System.out.printf("Move a disk from %c to %c.%n", rod_from, rod_to);
}
}
function hanoi(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
if (diskCount === 1) {
console.log(`Move a disk from ${rodFrom} to ${rodTo}.`);
}
}
func hanoi(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
if disk_count == 1 {
fmt.Printf("Move a disk from %c to %c.\n", rod_from, rod_to)
}
}
pub fn hanoi(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
if disk_count == 1 {
println!("Move a disk from {rod_from} to {rod_to}.");
} else {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
}
}
public static void hanoi(final int disk_count, final char rod_from, final char rod_temp, final char rod_to) {
if (disk_count == 1) {
System.out.printf("Move a disk from %c to %c.%n", rod_from, rod_to);
} else {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
}
}
function hanoi(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
if (diskCount === 1) {
console.log(`Move a disk from ${rodFrom} to ${rodTo}.`);
} else {
hanoi(diskCount - 1, rodFrom, rodTo, rodTemp);
}
}
func hanoi(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
if disk_count == 1 {
fmt.Printf("Move a disk from %c to %c.\n", rod_from, rod_to)
} else {
hanoi(disk_count-1, rod_from, rod_to, rod_temp)
}
}
接着是步骤二,将起始的杆子上剩下来的一个盘片移动到结束的杆子上。代码如下:
pub fn hanoi(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
if disk_count == 1 {
println!("Move a disk from {rod_from} to {rod_to}.");
} else {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
hanoi(1, rod_from, rod_temp, rod_to);
}
}
public static void hanoi(final int disk_count, final char rod_from, final char rod_temp, final char rod_to) {
if (disk_count == 1) {
System.out.printf("Move a disk from %c to %c.%n", rod_from, rod_to);
} else {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
hanoi(1, rod_from, rod_temp, rod_to);
}
}
function hanoi(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
if (diskCount === 1) {
console.log(`Move a disk from ${rodFrom} to ${rodTo}.`);
} else {
hanoi(diskCount - 1, rodFrom, rodTo, rodTemp);
hanoi(1, rodFrom, rodTemp, rodTo);
}
}
func hanoi(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
if disk_count == 1 {
fmt.Printf("Move a disk from %c to %c.\n", rod_from, rod_to)
} else {
hanoi(disk_count-1, rod_from, rod_to, rod_temp)
hanoi(1, rod_from, rod_temp, rod_to)
}
}
最后是步骤三,移动暂存的杆子上所有的,也就是 #{{n - 1}}# 个盘片到结束的杆子上。代码如下:
pub fn hanoi(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
if disk_count == 1 {
println!("Move a disk from {rod_from} to {rod_to}.");
} else {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
hanoi(1, rod_from, rod_temp, rod_to);
hanoi(disk_count - 1, rod_temp, rod_from, rod_to);
}
}
public static void hanoi(final int disk_count, final char rod_from, final char rod_temp, final char rod_to) {
if (disk_count == 1) {
System.out.printf("Move a disk from %c to %c.%n", rod_from, rod_to);
} else {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
hanoi(1, rod_from, rod_temp, rod_to);
hanoi(disk_count - 1, rod_temp, rod_from, rod_to);
}
}
function hanoi(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
if (diskCount === 1) {
console.log(`Move a disk from ${rodFrom} to ${rodTo}.`);
} else {
hanoi(diskCount - 1, rodFrom, rodTo, rodTemp);
hanoi(1, rodFrom, rodTemp, rodTo);
hanoi(diskCount - 1, rodTemp, rodFrom, rodTo);
}
}
func hanoi(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
if disk_count == 1 {
fmt.Printf("Move a disk from %c to %c.\n", rod_from, rod_to)
} else {
hanoi(disk_count-1, rod_from, rod_to, rod_temp)
hanoi(1, rod_from, rod_temp, rod_to)
hanoi(disk_count-1, rod_temp, rod_from, rod_to)
}
}
至此我们就完成递归版本的河内塔函数了!很简单吧!不过笔者当初接触到河内塔的递归函数的时候,根本看不懂它在干嘛,所以是直接把它背起来,应付考试而已。后来从头开始厘清河内塔到底在干什么,自然就可以写出递归函数了,完全不需要背。
另外我们根据一个盘片的河内塔最少要移动 1 次来完成、两个盘片的河内塔最少要移动 3 次来完成、三个盘片的河内塔最少要移动 7 次来完成、四个盘片的河内塔最少要移动 15 次来完成,推测出 #{{n}}# 个盘片至少需要移动 #{{2^n - 1}}# 次来完成。利用数学归纳法的证明过程如下。
设 #{{S_n}}# 为 #{{n}}# 个盘片最少所需要的移动次数,而根据那三个步骤,我们知道 #{{S_{n + 1} = S_n + 1 + S_n}}#。
#{{{
\begin{alignedat}{2}
\\
\text{证明 } S_n &{}={}&& 2^n - 1, n \in \mathbb{N^+} \\
\\
n = 1, \\
S_1 &{}={}&& 2^1 - 1 = 1 \text{ (成立)} \\
\\
\text{假设 } n = k, \\
S_{k} &{}={}&& 2^k - 1 \\
\\
n = k + 1, \\
S_{k + 1} &{}={}&& S_k + 1 + S_k \\
&{}={}&& 2^k - 1 + 1 + 2^k - 1 \\
&{}={}&& 2^k + 2^k - 1 + 1 - 1 \\
&{}={}&& 2 \times 2^k - 1 \\
&{}={}&& 2^{k + 1} - 1 \\
\\
\therefore S_n &{}={}&& 2^n - 1, n \in \mathbb{N^+} \text{ 是正确的}
\end{alignedat}
}}}#
程序写出来了,但还是不知道怎么玩河内塔……
即便理解河内塔主要想展示的思想(大问题分解成小问题,也就是递归啦),在现实中使用教具或是桌游玩具玩河内塔,甚至是玩河内塔的电子游戏时,盘片数量超过三个的时候还是不知道该如何下手啊!毕竟人脑不像电脑那样,可以快速以递归的方式来思考问题。
所以我们必须要再想个「迭代」的方式来解决河内塔的问题。
在开始想之前,可以先看看下面这篇文章,将递归版本的河内塔直接转成迭代版本。
转出来的程序如下:
pub fn hanoi(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
let mut stack = Vec::new();
stack.push((disk_count, rod_from, rod_temp, rod_to));
while let Some((disk_count, rod_from, rod_temp, rod_to)) = stack.pop() {
if disk_count == 1 {
println!("Move a disk from {rod_from} to {rod_to}.");
} else {
stack.push((disk_count - 1, rod_temp, rod_from, rod_to));
stack.push((1, rod_from, rod_temp, rod_to));
stack.push((disk_count - 1, rod_from, rod_to, rod_temp));
}
}
}
public static void hanoi(int disk_count, char rod_from, char rod_temp, char rod_to) {
final Stack<Object> stack = new Stack<>();
stack.push(disk_count);
stack.push(rod_from);
stack.push(rod_temp);
stack.push(rod_to);
while (!stack.empty()) {
rod_to = (char) stack.pop();
rod_temp = (char) stack.pop();
rod_from = (char) stack.pop();
disk_count = (int) stack.pop();
if (disk_count == 1) {
System.out.printf("Move a disk from %c to %c.%n", rod_from, rod_to);
} else {
stack.push(disk_count - 1);
stack.push(rod_temp);
stack.push(rod_from);
stack.push(rod_to);
stack.push(1);
stack.push(rod_from);
stack.push(rod_temp);
stack.push(rod_to);
stack.push(disk_count - 1);
stack.push(rod_from);
stack.push(rod_to);
stack.push(rod_temp);
}
}
}
function hanoi(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
const stack: [number, string, string, string][] = [];
stack.push([
diskCount, rodFrom, rodTemp, rodTo,
]);
while (stack.length > 0) {
[
diskCount, rodFrom, rodTemp, rodTo,
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
] = stack.pop()!;
if (diskCount === 1) {
console.log(`Move a disk from ${rodFrom} to ${rodTo}.`);
} else {
stack.push([
diskCount - 1, rodTemp, rodFrom, rodTo,
]);
stack.push([
1, rodFrom, rodTemp, rodTo,
]);
stack.push([
diskCount - 1, rodFrom, rodTo, rodTemp,
]);
}
}
}
type stack []interface{}
func (s stack) Push(v interface{}) stack {
return append(s, v)
}
func (s stack) PopRune() (stack, rune) {
l := len(s)
return s[:l-1], s[l-1].(rune)
}
func (s stack) PopInt() (stack, int) {
l := len(s)
return s[:l-1], s[l-1].(int)
}
func hanoi(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
stack := make(stack, 0)
stack = stack.Push(disk_count)
stack = stack.Push(rod_from)
stack = stack.Push(rod_temp)
stack = stack.Push(rod_to)
for len(stack) > 0 {
stack, rod_to = stack.PopRune()
stack, rod_temp = stack.PopRune()
stack, rod_from = stack.PopRune()
stack, disk_count = stack.PopInt()
if disk_count == 1 {
fmt.Printf("Move a disk from %c to %c.\n", rod_from, rod_to)
} else {
stack = stack.Push(disk_count - 1)
stack = stack.Push(rod_temp)
stack = stack.Push(rod_from)
stack = stack.Push(rod_to)
stack = stack.Push(1)
stack = stack.Push(rod_from)
stack = stack.Push(rod_temp)
stack = stack.Push(rod_to)
stack = stack.Push(disk_count - 1)
stack = stack.Push(rod_from)
stack = stack.Push(rod_to)
stack = stack.Push(rod_temp)
}
}
}
以上的河内塔函数,虽然已经是迭代版本了没错,但骨子里还是用递归(或者更准确来说是 Top-down)的方式在算的,看看就好。
其实多玩几次三个盘片的河内塔和四个盘片的河内塔(或是也可以玩两个盘片,如果您真的不太会玩河内塔的话),就可以发现如果要用最少的步数来完成河内塔的话,三个盘片和四个盘片分别在一开始,最小的盘片必须要移动往不同的杆子。像是三个盘片的河内塔,第一步就必须要先将最小的盘片从 A 杆移到 C 杆;而四个盘片的河内塔,第一步就必须要先将最小的盘片从 A 杆移到 B 杆。这是为了要确保 #{{n - 1}}# 个盘片在移动之后,是在暂存的杆子上,而不是在结束的杆子上,好让我们能把起始的杆子上的最大的盘片移动到结束的杆子。若 #{{n - 1}}# 个盘片在移动之后,是在结束的杆子上,那我们也就只能再把 #{{n - 1}}# 个盘片搬到暂存的杆子上后,才能把起始的杆子上的最大的盘片移动到结束的杆子。
也就是说,河内塔第一步最小的盘片移动的方式,要根据盘片的数量是奇数还是偶数来决定。如果是三个盘片的河内塔,那第一步就是把最小的盘片从 A 杆移到 C 杆;如果是四个盘片的河内塔,那第一步就是把最小的盘片从 A 杆移到 B 杆。
若您还不了解的话,试想一下,若我们玩四个盘片的河内塔,第一步是把最小的盘片从 A 杆移到 C 杆的话,那不就跟在玩三个盘片的河内塔时一样,就会先把三个盘片移动到 C 杆了,然后又得把那三个盘片再移到 B 杆上,才能将 A 杆上最大的盘片移到 C 杆,所以这对四个盘片的河内塔游戏来说也就不会是一个最佳的解决方式。
所以知道第一步要怎么移之后呢?我们都知道河内塔的盘片只是大的在下、小的在上,因此最小的盘片在被移动之后,势必得赶紧移回第二小的盘片之上,不然任何其它的盘片都无法使用最小的盘片所在的杆子。当然,我们不会在移动完最小的盘片后,下一步又把它移回去,或者又把它移动到另一个杆子上,因为这样一点意义都没有。也就是说,我们合理能做的第二步,就是将第二小的盘片移动到另一个杆子上,然后在第三步的时候,把最小的盘片移到第二小的盘片所在的杆子上。此时就完成了两个盘片的移动。
再来要进行第四步的时候,我们就会发现,除了将最小的盘片又移动到其它杆子上外,其实也只剩下一种移动方式。在此时若将最小的盘片又移动到其它杆子上,就等同于又要开始进行最小和第二小的盘片的移动,没有意义。所以我们也只能够选择剩下的那一种移动方式。
第五步时,我们不考虑去还原第四步,就只会剩下一种移动方式,那就是花费三步(第五步、第六步、第七步)去移动最小和第二小的盘片。
第八步时,同理,除了将最小的盘片又移动到其它杆子上外,其实也只剩下一种移动方式。
聪明的读者们大概都看得出来这其中的规律了吧!也就是「四步一循环」:移动最小的盘片→移动第二小的盘片→移动最小的盘片到第二小的盘片上→移动其它的盘片。
现在的问题是在于,「移动最小的盘片」时,该盘片因为最小,所以另外两个杆子都可以成为目标,但除了第一步我们知道最小的盘片究竟要移动到哪个杆子之外,第五步、第九步……到达这些后续的步数时,就不知道该怎么移动了。
事实上,如果我们观察河内塔最短步数的移动方式,会在「移动最小的盘片」的步骤时,发现它们总是往同一个「方向」移动一个距离。以三个盘片的河内塔来说,一开始将最小的盘片从 A 杆移到 C 杆,看作是「向左」(A 杆子向左会到 C 杆子,形成循环);而四个盘片的河内塔,一开始将最小的盘片从 A 杆移到 B 杆,看作是「向右」(C 杆子向右会到 A 杆子,形成循环)。找出这个「向左」、「向右」规律后,我们可以扩充一下我们刚刚发现的「四步一循环」规则:
- 0. 判断盘片的数量是奇数还是偶数,来决定最小的盘片和第二小的盘片移动时的方向。偶数往右;奇数往左。
- 1. 移动最小的盘片一个杆子的距离。
- 2. 移动第二小的盘片两个杆子的距离。
- 3. 移动最小的盘片一个杆子的距离。(将最小的盘片移动到第二小的盘片上。)
- 4. 移动其它的盘片。
如此一来在游玩河内塔的时候,我们可以在心中默念「一、二、三、四」,按照步骤来解决河内塔,完全不需要动脑。
总算会玩了吧!那用这样的方式写程序来实作一个迭代版本的河内塔函数如何?程序如下:
fn move_disk(from: char, to: char) {
println!("Move a disk from {from} to {to}.");
}
pub fn hanoi_iteratively(disk_count: usize, mut rod_from: char, mut rod_temp: char, mut rod_to: char) {
if disk_count & 1 == 1 {
let temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
let end = 2f64.powf(disk_count as f64) as usize - 1;
let mut step = 1;
for _ in 0..end {
match step {
1 => move_disk(rod_from, rod_temp),
2 => move_disk(rod_from, rod_to),
3 => move_disk(rod_temp, rod_to),
_ => {
println!("Move a disk from ? to ?.");
let from = rod_from;
let temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
}
step += 1;
}
}
static void moveDisk(final char from, final char to) {
System.out.printf("Move a disk from %c to %c.%n", from, to);
}
public static void hanoiIteratively(final int disk_count, char rod_from, char rod_temp, char rod_to) {
if ((disk_count & 1) == 1) {
final char temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
final int end = (int) Math.pow(2, disk_count) - 1;
int step = 1;
for (int i = 0; i < end; ++i) {
switch (step) {
case 1:
moveDisk(rod_from, rod_temp);
break;
case 2:
moveDisk(rod_from, rod_to);
break;
case 3:
moveDisk(rod_temp, rod_to);
break;
case 4:
System.out.println("Move a disk from ? to ?.");
final char from = rod_from;
final char temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
++step;
}
}
function moveDisk(from: string, to: string) {
console.log(`Move a disk from ${from} to ${to}.`);
}
function hanoiIteratively(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
if ((diskCount & 1) === 1) {
const temp = rodTemp;
rodTemp = rodTo;
rodTo = temp;
}
const end = (2 ** diskCount) - 1;
let step = 1;
for (let i = 0;i < end;i++) {
switch (step) {
case 1:
moveDisk(rodFrom, rodTemp);
break;
case 2:
moveDisk(rodFrom, rodTo);
break;
case 3:
moveDisk(rodTemp, rodTo);
break;
case 4: {
console.log("Move a disk from ? to ?.");
const from = rodFrom;
const temp = rodTemp;
rodFrom = rodTo;
rodTemp = from;
rodTo = temp;
step = 1;
continue;
}
}
step += 1;
}
}
func moveDisk(from rune, to rune) {
fmt.Printf("Move a disk from %c to %c.\n", from, to)
}
func hanoiIteratively(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
if disk_count&1 == 1 {
temp := rod_temp
rod_temp = rod_to
rod_to = temp
}
end := int(math.Pow(2.0, float64(disk_count))) - 1
step := 1
for i := 0; i < end; i++ {
switch step {
case 1:
moveDisk(rod_from, rod_temp)
case 2:
moveDisk(rod_from, rod_to)
case 3:
moveDisk(rod_temp, rod_to)
case 4:
fmt.Println("Move a disk from ? to ?.")
from := rod_from
temp := rod_temp
rod_from = rod_to
rod_temp = from
rod_to = temp
step = 1
continue
}
step++
}
}
以上程序,将「向左」、「向右」的问题以交换除了起始的杆子之外的两个杆子来简化。试想一下,向右的顺序如果是 ABCABC,那么向左就是 ACBACB,这不就是把 B、C 两个杆子交换了吗?
再来,一个循环的第四步如果我们不知道当下盘片的分布情形,就不知道要怎么移动了(以上程序先以 Move a disk from ? to ?. 来输出)。所以我们必须在每步都去改变并记录盘片的分布情形才行,可以用一个堆栈来模拟一个杆子,三个杆子就是三个堆栈。将以上程序加入堆栈后的样子如下:
fn move_disk(stacks: &mut [Vec<usize>], rod_names: &[char], from: usize, to: usize) {
let disk = stacks[from].pop().unwrap();
stacks[to].push(disk);
println!("Move a disk from {} to {}.", rod_names[from], rod_names[to]);
}
pub fn hanoi_iteratively(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
let rod_names = [rod_from, rod_temp, rod_to];
let mut stacks = [Vec::new(), Vec::new(), Vec::new()];
let mut rod_from = 0;
let mut rod_temp = 1;
let mut rod_to = 2;
if disk_count & 1 == 1 {
let temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
for stack in stacks.iter_mut() {
stack.push(0);
}
for i in 1..=disk_count {
stacks[rod_from].push(i);
}
let end = 2f64.powf(disk_count as f64) as usize - 1;
let mut step = 1;
for _ in 0..end {
match step {
1 => move_disk(&mut stacks, &rod_names, rod_from, rod_temp),
2 => move_disk(&mut stacks, &rod_names, rod_from, rod_to),
3 => move_disk(&mut stacks, &rod_names, rod_temp, rod_to),
_ => {
println!("Move a disk from ? to ?.");
let from = rod_from;
let temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
}
step += 1;
}
}
static void moveDisk(final Stack<Integer>[] stacks, final char[] rod_names, final int from, final int to) {
final Integer disk = stacks[from].pop();
stacks[to].push(disk);
System.out.printf("Move a disk from %c to %c.%n", rod_names[from], rod_names[to]);
}
public static void hanoiIteratively(final int disk_count, char rod_from_name, char rod_temp_name, char rod_to_name) {
final char[] rod_names = new char[]{rod_from_name, rod_temp_name, rod_to_name};
final Stack<Integer>[] stacks = new Stack[]{new Stack<>(), new Stack<>(), new Stack<>()};
int rod_from = 0;
int rod_temp = 1;
int rod_to = 2;
if ((disk_count & 1) == 1) {
final int temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
for (int i = 0; i < stacks.length; ++i) {
stacks[i].push(0);
}
for (int i = 1; i <= disk_count; ++i) {
stacks[rod_from].push(i);
}
final int end = (int) Math.pow(2, disk_count) - 1;
int step = 1;
for (int i = 0; i < end; ++i) {
switch (step) {
case 1:
moveDisk(stacks, rod_names, rod_from, rod_temp);
break;
case 2:
moveDisk(stacks, rod_names, rod_from, rod_to);
break;
case 3:
moveDisk(stacks, rod_names, rod_temp, rod_to);
break;
case 4:
System.out.println("Move a disk from ? to ?.");
final int from = rod_from;
final int temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
++step;
}
}
function moveDisk(stacks: number[][], rodNames: string[], from: number, to: number) {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const disk = stacks[from].pop()!;
stacks[to].push(disk);
console.log(`Move a disk from ${rodNames[from]} to ${rodNames[to]}.`);
}
function hanoiIteratively(diskCount: number, rodFromName: string, rodTempName: string, rodToName: string) {
const rodNames = [rodFromName, rodTempName, rodToName];
const stacks: number[][] = [[], [], []];
let rodFrom = 0;
let rodTemp = 1;
let rodTo = 2;
if ((diskCount & 1) === 1) {
const temp = rodTemp;
rodTemp = rodTo;
rodTo = temp;
}
for (const stack of stacks) {
stack.push(0);
}
for (let i = 1;i <= diskCount;i++) {
stacks[rodFrom].push(i);
}
const end = (2 ** diskCount) - 1;
let step = 1;
for (let i = 0;i < end;i++) {
switch (step) {
case 1:
moveDisk(stacks, rodNames, rodFrom, rodTemp);
break;
case 2:
moveDisk(stacks, rodNames, rodFrom, rodTo);
break;
case 3:
moveDisk(stacks, rodNames, rodTemp, rodTo);
break;
case 4: {
console.log("Move a disk from ? to ?.");
const from = rodFrom;
const temp = rodTemp;
rodFrom = rodTo;
rodTemp = from;
rodTo = temp;
step = 1;
continue;
}
}
step += 1;
}
}
type stack []int
func (s stack) Push(v int) stack {
return append(s, v)
}
func (s stack) Pop() (stack, int) {
l := len(s)
return s[:l-1], s[l-1]
}
func moveDisk(stacks []stack, rod_names []rune, from int, to int) {
var disk int
stacks[from], disk = stacks[from].Pop()
stacks[to] = stacks[to].Push(disk)
fmt.Printf("Move a disk from %c to %c.\n", rod_names[from], rod_names[to])
}
func hanoiIteratively(disk_count int, rod_from_name rune, rod_temp_name rune, rod_to_name rune) {
rod_names := []rune{rod_from_name, rod_temp_name, rod_to_name}
stacks := []stack{make(stack, 0), make(stack, 0), make(stack, 0)}
rod_from := 0
rod_temp := 1
rod_to := 2
if disk_count&1 == 1 {
temp := rod_temp
rod_temp = rod_to
rod_to = temp
}
for i := 0; i < len(stacks); i++ {
stacks[i] = stacks[i].Push(0)
}
for i := 1; i <= disk_count; i++ {
stacks[rod_from] = stacks[rod_from].Push(i)
}
end := int(math.Pow(2.0, float64(disk_count))) - 1
step := 1
for i := 0; i < end; i++ {
switch step {
case 1:
moveDisk(stacks, rod_names, rod_from, rod_temp)
case 2:
moveDisk(stacks, rod_names, rod_from, rod_to)
case 3:
moveDisk(stacks, rod_names, rod_temp, rod_to)
case 4:
fmt.Println("Move a disk from ? to ?.")
from := rod_from
temp := rod_temp
rod_from = rod_to
rod_temp = from
rod_to = temp
step = 1
continue
}
step++
}
}
以上程序,创建了三个堆栈来保存盘片(数值愈小的盘片尺寸愈大。0 表示杆子的底部,以一个尺寸最大的盘片来模拟,所以移不走)。再来就是要处理每个循环的第四步,盘片要怎么移动了。其实这个很简单,我们只需判断前两小的盘片所在的另外两个杆子,看它们顶部保存的数值哪个比较大,就从顶部数值比较大的杆子移到顶部数值比较小的杆子。
所以最终的代码如下:
fn move_disk(stacks: &mut [Vec<usize>], rod_names: &[char], from: usize, to: usize) {
let disk = stacks[from].pop().unwrap();
stacks[to].push(disk);
println!("Move a disk from {} to {}.", rod_names[from], rod_names[to]);
}
pub fn hanoi_iteratively(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
let rod_names = [rod_from, rod_temp, rod_to];
let mut stacks = [Vec::new(), Vec::new(), Vec::new()];
let mut rod_from = 0;
let mut rod_temp = 1;
let mut rod_to = 2;
if disk_count & 1 == 1 {
let temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
for stack in stacks.iter_mut() {
stack.push(0);
}
for i in 1..=disk_count {
stacks[rod_from].push(i);
}
let end = 2f64.powf(disk_count as f64) as usize - 1;
let mut step = 1;
for _ in 0..end {
match step {
1 => move_disk(&mut stacks, &rod_names, rod_from, rod_temp),
2 => move_disk(&mut stacks, &rod_names, rod_from, rod_to),
3 => move_disk(&mut stacks, &rod_names, rod_temp, rod_to),
_ => {
if stacks[rod_from].last().unwrap() > stacks[rod_temp].last().unwrap() {
move_disk(&mut stacks, &rod_names, rod_from, rod_temp);
} else {
move_disk(&mut stacks, &rod_names, rod_temp, rod_from);
}
let from = rod_from;
let temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
}
step += 1;
}
}
static void moveDisk(final Stack<Integer>[] stacks, final char[] rod_names, final int from, final int to) {
final Integer disk = stacks[from].pop();
stacks[to].push(disk);
System.out.printf("Move a disk from %c to %c.%n", rod_names[from], rod_names[to]);
}
public static void hanoiIteratively(final int disk_count, char rod_from_name, char rod_temp_name, char rod_to_name) {
final char[] rod_names = new char[]{rod_from_name, rod_temp_name, rod_to_name};
final Stack<Integer>[] stacks = new Stack[]{new Stack<>(), new Stack<>(), new Stack<>()};
int rod_from = 0;
int rod_temp = 1;
int rod_to = 2;
if ((disk_count & 1) == 1) {
final int temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
for (int i = 0; i < stacks.length; ++i) {
stacks[i].push(0);
}
for (int i = 1; i <= disk_count; ++i) {
stacks[rod_from].push(i);
}
final int end = (int) Math.pow(2, disk_count) - 1;
int step = 1;
for (int i = 0; i < end; ++i) {
switch (step) {
case 1:
moveDisk(stacks, rod_names, rod_from, rod_temp);
break;
case 2:
moveDisk(stacks, rod_names, rod_from, rod_to);
break;
case 3:
moveDisk(stacks, rod_names, rod_temp, rod_to);
break;
case 4:
if (stacks[rod_from].peek() > stacks[rod_temp].peek()) {
moveDisk(stacks, rod_names, rod_from, rod_temp);
} else {
moveDisk(stacks, rod_names, rod_temp, rod_from);
}
final int from = rod_from;
final int temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
++step;
}
}
function moveDisk(stacks: number[][], rodNames: string[], from: number, to: number) {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const disk = stacks[from].pop()!;
stacks[to].push(disk);
console.log(`Move a disk from ${rodNames[from]} to ${rodNames[to]}.`);
}
function hanoiIteratively(diskCount: number, rodFromName: string, rodTempName: string, rodToName: string) {
const rodNames = [rodFromName, rodTempName, rodToName];
const stacks: number[][] = [[], [], []];
let rodFrom = 0;
let rodTemp = 1;
let rodTo = 2;
if ((diskCount & 1) === 1) {
const temp = rodTemp;
rodTemp = rodTo;
rodTo = temp;
}
for (const stack of stacks) {
stack.push(0);
}
for (let i = 1;i <= diskCount;i++) {
stacks[rodFrom].push(i);
}
const end = (2 ** diskCount) - 1;
let step = 1;
for (let i = 0;i < end;i++) {
switch (step) {
case 1:
moveDisk(stacks, rodNames, rodFrom, rodTemp);
break;
case 2:
moveDisk(stacks, rodNames, rodFrom, rodTo);
break;
case 3:
moveDisk(stacks, rodNames, rodTemp, rodTo);
break;
case 4: {
if (stacks[rodFrom][stacks[rodFrom].length - 1] > stacks[rodTemp][stacks[rodTemp].length - 1]) {
moveDisk(stacks, rodNames, rodFrom, rodTemp);
} else {
moveDisk(stacks, rodNames, rodTemp, rodFrom);
}
const from = rodFrom;
const temp = rodTemp;
rodFrom = rodTo;
rodTemp = from;
rodTo = temp;
step = 1;
continue;
}
}
step += 1;
}
}
type stack []int
func (s stack) Push(v int) stack {
return append(s, v)
}
func (s stack) Pop() (stack, int) {
l := len(s)
return s[:l-1], s[l-1]
}
func (s stack) Peek() int {
l := len(s)
return s[l-1]
}
func moveDisk(stacks []stack, rod_names []rune, from int, to int) {
var disk int
stacks[from], disk = stacks[from].Pop()
stacks[to] = stacks[to].Push(disk)
fmt.Printf("Move a disk from %c to %c.\n", rod_names[from], rod_names[to])
}
func hanoiIteratively(disk_count int, rod_from_name rune, rod_temp_name rune, rod_to_name rune) {
rod_names := []rune{rod_from_name, rod_temp_name, rod_to_name}
stacks := []stack{make(stack, 0), make(stack, 0), make(stack, 0)}
rod_from := 0
rod_temp := 1
rod_to := 2
if disk_count&1 == 1 {
temp := rod_temp
rod_temp = rod_to
rod_to = temp
}
for i := 0; i < len(stacks); i++ {
stacks[i] = stacks[i].Push(0)
}
for i := 1; i <= disk_count; i++ {
stacks[rod_from] = stacks[rod_from].Push(i)
}
end := int(math.Pow(2.0, float64(disk_count))) - 1
step := 1
for i := 0; i < end; i++ {
switch step {
case 1:
moveDisk(stacks, rod_names, rod_from, rod_temp)
case 2:
moveDisk(stacks, rod_names, rod_from, rod_to)
case 3:
moveDisk(stacks, rod_names, rod_temp, rod_to)
case 4:
if stacks[rod_from].Peek() > stacks[rod_temp].Peek() {
moveDisk(stacks, rod_names, rod_from, rod_temp)
} else {
moveDisk(stacks, rod_names, rod_temp, rod_from)
}
from := rod_from
temp := rod_temp
rod_from = rod_to
rod_temp = from
rod_to = temp
step = 1
continue
}
step++
}
}
这边再介绍另一个河内塔迭代版的算法,现实中在玩河内塔的时候也可以使用,但是会比较烧脑一点。
如果仔细观察河内塔最短路径的解,可以发现一个「三步一循环」的规律,而且有区分偶数和奇数的盘片数量。偶数就是「AB→AC→BC」,奇数就是「AC→AB→BC」。
什么意思?
如果盘片数量为偶数,在这三步组成的循环中,第一步我们只需要去看 A、B 这两个杆子,看是要把盘片从 A 杆移到 B 杆,还是要反过来从 B 杆移到 A 杆;第二步只需要去看 A、C 这两个杆子,看是要把盘片从 A 杆移到 C 杆,还是要反过来从 C 杆移到 A 杆;第三步只需要去看 B、C 这两个杆子,看是要把盘片从 B 杆移到 C 杆,还是要反过来从 C 杆移到 B 杆。
与先前同样地,若要以程序来实作,当盘片数量为奇数时,可以先去交换 B、C 两个杆子,这样一来「三步一循环」的规律就只剩下「AB→AC→BC」了。所以可以写出以下迭代版本的河内塔函数:
fn move_disk(stacks: &mut [Vec<usize>], rod_names: &[char], from: usize, to: usize) {
let disk = stacks[from].pop().unwrap();
stacks[to].push(disk);
println!("Move a disk from {} to {}.", rod_names[from], rod_names[to]);
}
fn move_between_rods(stacks: &mut [Vec<usize>], rod_names: &[char], x: usize, y: usize) {
if stacks[x].last().unwrap() > stacks[y].last().unwrap() {
move_disk(stacks, rod_names, x, y);
} else {
move_disk(stacks, rod_names, y, x);
}
}
pub fn hanoi_iteratively(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
let rod_names = [rod_from, rod_temp, rod_to];
let mut stacks = [Vec::new(), Vec::new(), Vec::new()];
let a = 0;
let mut b = 1;
let mut c = 2;
if disk_count & 1 == 1 {
let temp = b;
b = c;
c = temp;
}
for stack in stacks.iter_mut() {
stack.push(0);
}
for i in 1..=disk_count {
stacks[a].push(i);
}
let end = 2f64.powf(disk_count as f64) as usize - 1;
let mut step = 1;
for _ in 0..end {
match step {
1 => move_between_rods(&mut stacks, &rod_names, a, b),
2 => move_between_rods(&mut stacks, &rod_names, a, c),
_ => {
move_between_rods(&mut stacks, &rod_names, b, c);
step = 1;
continue;
}
}
step += 1;
}
}
static void moveDisk(final Stack<Integer>[] stacks, final char[] rod_names, final int from, final int to) {
final Integer disk = stacks[from].pop();
stacks[to].push(disk);
System.out.printf("Move a disk from %c to %c.%n", rod_names[from], rod_names[to]);
}
static void moveBetweenRods(final Stack<Integer>[] stacks, final char[] rod_names, final int x, final int y) {
if (stacks[x].peek() > stacks[y].peek()) {
moveDisk(stacks, rod_names, x, y);
} else {
moveDisk(stacks, rod_names, y, x);
}
}
public static void hanoiIteratively(final int disk_count, char rod_from_name, char rod_temp_name, char rod_to_name) {
final char[] rod_names = new char[]{rod_from_name, rod_temp_name, rod_to_name};
final Stack<Integer>[] stacks = new Stack[]{new Stack<>(), new Stack<>(), new Stack<>()};
final int a = 0;
int b = 1;
int c = 2;
if ((disk_count & 1) == 1) {
final int temp = b;
b = c;
c = temp;
}
for (int i = 0; i < stacks.length; ++i) {
stacks[i].push(0);
}
for (int i = 1; i <= disk_count; ++i) {
stacks[a].push(i);
}
final int end = (int) Math.pow(2, disk_count) - 1;
int step = 1;
for (int i = 0; i < end; ++i) {
switch (step) {
case 1:
moveBetweenRods(stacks, rod_names, a, b);
break;
case 2:
moveBetweenRods(stacks, rod_names, a, c);
break;
default:
moveBetweenRods(stacks, rod_names, b, c);
step = 1;
continue;
}
++step;
}
}
function moveDisk(stacks: number[][], rodNames: string[], from: number, to: number) {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const disk = stacks[from].pop()!;
stacks[to].push(disk);
console.log(`Move a disk from ${rodNames[from]} to ${rodNames[to]}.`);
}
function moveBetweenRods(stacks: number[][], rodNames: string[], x: number, y: number) {
if (stacks[x][stacks[x].length - 1] > stacks[y][stacks[y].length - 1]) {
moveDisk(stacks, rodNames, x, y);
} else {
moveDisk(stacks, rodNames, y, x);
}
}
function hanoiIteratively(diskCount: number, rodFromName: string, rodTempName: string, rodToName: string) {
const rodNames = [rodFromName, rodTempName, rodToName];
const stacks: number[][] = [[], [], []];
const a = 0;
let b = 1;
let c = 2;
if ((diskCount & 1) === 1) {
const temp = b;
b = c;
c = temp;
}
for (const stack of stacks) {
stack.push(0);
}
for (let i = 1;i <= diskCount;i++) {
stacks[a].push(i);
}
const end = (2 ** diskCount) - 1;
let step = 1;
for (let i = 0;i < end;i++) {
switch (step) {
case 1:
moveBetweenRods(stacks, rodNames, a, b);
break;
case 2:
moveBetweenRods(stacks, rodNames, a, c);
break;
case 3:
moveBetweenRods(stacks, rodNames, b, c);
step = 1;
continue;
}
step += 1;
}
}
type stack []int
func (s stack) Push(v int) stack {
return append(s, v)
}
func (s stack) Pop() (stack, int) {
l := len(s)
return s[:l-1], s[l-1]
}
func (s stack) Peek() int {
l := len(s)
return s[l-1]
}
func moveDisk(stacks []stack, rod_names []rune, from int, to int) {
var disk int
stacks[from], disk = stacks[from].Pop()
stacks[to] = stacks[to].Push(disk)
fmt.Printf("Move a disk from %c to %c.\n", rod_names[from], rod_names[to])
}
func moveBetweenRods(stacks []stack, rod_names []rune, x int, y int) {
if stacks[x].Peek() > stacks[y].Peek() {
moveDisk(stacks, rod_names, x, y)
} else {
moveDisk(stacks, rod_names, y, x)
}
}
func hanoiIteratively(disk_count int, rod_from_name rune, rod_temp_name rune, rod_to_name rune) {
rod_names := []rune{rod_from_name, rod_temp_name, rod_to_name}
stacks := []stack{make(stack, 0), make(stack, 0), make(stack, 0)}
a := 0
b := 1
c := 2
if disk_count&1 == 1 {
temp := b
b = c
c = temp
}
for i := 0; i < len(stacks); i++ {
stacks[i] = stacks[i].Push(0)
}
for i := 1; i <= disk_count; i++ {
stacks[a] = stacks[a].Push(i)
}
end := int(math.Pow(2.0, float64(disk_count))) - 1
step := 1
for i := 0; i < end; i++ {
switch step {
case 1:
moveBetweenRods(stacks, rod_names, a, b)
case 2:
moveBetweenRods(stacks, rod_names, a, c)
case 3:
moveBetweenRods(stacks, rod_names, b, c)
step = 1
continue
}
step++
}
}
不用堆栈空间的河内塔迭代算法
回顾我们一开始介绍的递归版本的河内塔算法:
步骤一:移动 A 杆子上的 #{{n - 1}}# 个盘片到 B 杆子上。
步骤二:移动 A 杆子剩下的一个盘片到 C 杆子上。
步骤三:移动 B 杆子上的所有(#{{n - 1}}# 个)盘片到 C 杆子上。
其实要把已知步骤的 #{{n}}# 个盘片从一个杆子搬到另一个杆子上是很容易的。举例来说,若要把三个盘片从 A 杆搬到 C 杆,搬移步骤如下:
Move a disk from A to B.
Move a disk from C to B.
Move a disk from A to C.
Move a disk from B to A.
Move a disk from B to C.
Move a disk from A to C.
而若要把三个盘片从 A 杆搬到 B 杆,搬移步骤如下:
Move a disk from A to C.
Move a disk from B to C.
Move a disk from A to B.
Move a disk from C to A.
Move a disk from C to B.
Move a disk from A to B.
有没有发现?其实我们只要把从 A 杆搬到 C 杆的路线中的 B、C 杆子交换就可以了。
而若要把三个盘片从 B 杆搬到 C 杆,搬移步骤如下:
Move a disk from B to A.
Move a disk from C to A.
Move a disk from B to C.
Move a disk from A to B.
Move a disk from A to C.
Move a disk from B to C.
有没有发现?其实我们只要把从 A 杆搬到 B 杆的路线中的 A 换成 B、B 换成 C、C 换成 A。
所以呢?
根据这个发现,要把 #{{n}}# 个盘片从 A 杆搬到 C 杆,我们可以先将 #{{n - 1}}# 个盘片搬到 C 杆(可沿用计算 #{{n - 1}}# 个盘片时找出的解),接着再把 B、C 杆子交换(利用 A 杆到 C 杆的路线,把 B、C 杆子交换),然后再把剩下的一个盘片从 A 杆搬到 C 杆,最后再把 B 杆的 #{{n - 1}}# 个盘片搬到 C 杆(利用 A 杆到 B 杆的路线,把 A 换成 B、B 换成 C、C 换成 A)。
为了快速地将路线进行置换,我们可以把六种(#{{P^3_2 = 6}}#)移动方式编号如下,称作「路线表」好了。
- 0: A→B
- 1: A→C
- 2: B→A
- 3: B→C
- 4: C→A
- 5: C→B
把「路线表」的 B、C 杆子交换,并依照原来 A→B、A→C、B→A、……的方式来排序,结果如下:
- 1: A→B
- 0: A→C
- 4: B→A
- 5: B→C
- 2: C→A
- 3: C→B
这样做可以让我们利用原先路线的编号,快速地对应到把 B、C 杆子交换后的结果。
把「路线表」的 A 换成 C、C 换成 B、B 换成 A,并依照原来 A→B、A→C、B→A、……的方式来排序,结果如下:
- 3: A→B
- 2: A→C
- 5: B→A
- 4: B→C
- 0: C→A
- 1: C→B
这样做可以让我们利用原先路线的编号,快速地对应到把 A 换成 B、B 换成 C、C 换成 A 后的结果。
再来我们就可以实作出不需堆栈空间(但需要暂存结果)的河内塔迭代函数:
pub fn hanoi(disk_count: usize, a: char, b: char, c: char) {
let bc_swap = [1, 0, 4, 5, 2, 3];
let a2b_b2c_c2a = [3, 2, 5, 4, 0, 1];
let number_of_total_steps = 2f64.powf(disk_count as f64) as usize - 1;
let mut route = Vec::with_capacity(number_of_total_steps);
unsafe {
route.set_len(number_of_total_steps);
}
let mut size = 1;
route[0] = 1;
for _ in 2..=disk_count {
for e in route.iter_mut().take(size) {
*e = bc_swap[*e];
}
route[size] = 1;
for i in 0..size {
route[size + i + 1] = a2b_b2c_c2a[route[i]];
}
size <<= 1;
size += 1;
}
for s in route {
let (rod_from, rod_to) = match s {
0 => (a, b),
1 => (a, c),
2 => (b, a),
3 => (b, c),
4 => (c, a),
_ => (c, b),
};
println!("Move a disk from {rod_from} to {rod_to}.");
}
}
public static void hanoi(final int disk_count, final char a, final char b, final char c) {
final int[] bc_swap = new int[]{1, 0, 4, 5, 2, 3};
final int[] a2b_b2c_c2a = new int[]{3, 2, 5, 4, 0, 1};
final int number_of_total_steps = (int) Math.pow(2, disk_count) - 1;
final int[] route = new int[number_of_total_steps];
int size = 1;
route[0] = 1;
for (int i = 2; i <= disk_count; ++i) {
for (int j = 0; j < size; ++j) {
route[j] = bc_swap[route[j]];
}
route[size] = 1;
for (int j = 0; j < size; ++j) {
route[size + j + 1] = a2b_b2c_c2a[route[j]];
}
size <<= 1;
size += 1;
}
for (final int s : route) {
final char rod_from, rod_to;
switch (s) {
case 0:
rod_from = a;
rod_to = b;
break;
case 1:
rod_from = a;
rod_to = c;
break;
case 2:
rod_from = b;
rod_to = a;
break;
case 3:
rod_from = b;
rod_to = c;
break;
case 4:
rod_from = c;
rod_to = a;
break;
default:
rod_from = c;
rod_to = b;
}
System.out.printf("Move a disk from %c to %c.%n", rod_from, rod_to);
}
}
function hanoi(diskCount: number, a: string, b: string, c: string) {
const bcSwap = [
1, 0, 4, 5, 2, 3,
];
const a2bB2cC2a = [
3, 2, 5, 4, 0, 1,
];
const numberOfTotalSteps = (2 ** diskCount) - 1;
const route = new Array<number>(numberOfTotalSteps);
let size = 1;
route[0] = 1;
for (let i = 2;i <= diskCount;i++) {
for (let j = 0;j < size;j++) {
route[j] = bcSwap[route[j]];
}
route[size] = 1;
for (let j = 0;j < size;j++) {
route[size + j + 1] = a2bB2cC2a[route[j]];
}
size <<= 1;
size += 1;
}
for (const r of route) {
let rodFrom;
let rodTo;
switch (r) {
case 0:
rodFrom = a;
rodTo = b;
break;
case 1:
rodFrom = a;
rodTo = c;
break;
case 2:
rodFrom = b;
rodTo = a;
break;
case 3:
rodFrom = b;
rodTo = c;
break;
case 4:
rodFrom = c;
rodTo = a;
break;
default:
rodFrom = c;
rodTo = b;
}
console.log(`Move a disk from ${rodFrom} to ${rodTo}.`);
}
}
func hanoi(disk_count int, a rune, b rune, c rune) {
bc_swap := [...]int{1, 0, 4, 5, 2, 3}
a2b_b2c_c2a := [...]int{3, 2, 5, 4, 0, 1}
number_of_total_steps := int(math.Pow(2.0, float64(disk_count))) - 1
route := make([]int, number_of_total_steps)
size := 1
route[0] = 1
for i := 2; i <= disk_count; i++ {
for j := 0; j < size; j++ {
route[j] = bc_swap[route[j]]
}
route[size] = 1
for j := 0; j < size; j++ {
route[size+j+1] = a2b_b2c_c2a[route[j]]
}
size <<= 1
size += 1
}
for _, s := range route {
var rod_from, rod_to rune
switch s {
case 0:
rod_from = a
rod_to = b
case 1:
rod_from = a
rod_to = c
case 2:
rod_from = b
rod_to = a
case 3:
rod_from = b
rod_to = c
case 4:
rod_from = c
rod_to = a
default:
rod_from = c
rod_to = b
}
fmt.Printf("Move a disk from %c to %c.\n", rod_from, rod_to)
}
}
让程序能输出盘片编号
为了让各位更容易了解,上面提供的代码都没有输出究竟是哪个盘片被移动了。所以最后就来提供一下,这些代码的「完整版」吧!
首先是递归版本的河内塔。(盘片数字愈小,尺寸愈小)
pub fn hanoi(disk_count: usize, rod_from: char, rod_temp: char, rod_to: char) {
if disk_count >= 1 {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
println!("Move #{disk_count} from {rod_from} to {rod_to}.");
hanoi(disk_count - 1, rod_temp, rod_from, rod_to);
}
}
public static void hanoi(final int disk_count, final char rod_from, final char rod_temp, final char rod_to) {
if (disk_count >= 1) {
hanoi(disk_count - 1, rod_from, rod_to, rod_temp);
System.out.printf("Move #%d from %c to %c.%n", disk_count, rod_from, rod_to);
hanoi(disk_count - 1, rod_temp, rod_from, rod_to);
}
}
function hanoi(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
if (diskCount >= 1) {
hanoi(diskCount - 1, rodFrom, rodTo, rodTemp);
console.log(`Move #${diskCount} from ${rodFrom} to ${rodTo}.`);
hanoi(diskCount - 1, rodTemp, rodFrom, rodTo);
}
}
func hanoi(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
if disk_count >= 1 {
hanoi(disk_count-1, rod_from, rod_to, rod_temp)
fmt.Printf("Move #%d from %c to %c.\n", disk_count, rod_from, rod_to)
hanoi(disk_count-1, rod_temp, rod_from, rod_to)
}
}
再来是「四步一循环」与「三步一循环」的堆栈空间迭代版所用的 move_disk 或 moveDisk 函数。(盘片数字愈小,尺寸愈大)
fn move_disk(stacks: &mut [Vec<usize>], rod_names: &[char], from: usize, to: usize) {
let disk = stacks[from].pop().unwrap();
stacks[to].push(disk);
println!("Move #{} from {} to {}.", disk, rod_names[from], rod_names[to]);
}
static void moveDisk(final Stack<Integer>[] stacks, final char[] rod_names, final int from, final int to) {
final Integer disk = stacks[from].pop();
stacks[to].push(disk);
System.out.printf("Move #%d from %c to %c.%n", disk, rod_names[from], rod_names[to]);
}
function moveDisk(stacks: number[][], rodNames: string[], from: number, to: number) {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const disk = stacks[from].pop()!;
stacks[to].push(disk);
console.log(`Move #${disk} from ${rodNames[from]} to ${rodNames[to]}.`);
}
func moveDisk(stacks []stack, rod_names []rune, from int, to int) {
var disk int
stacks[from], disk = stacks[from].Pop()
stacks[to] = stacks[to].Push(disk)
fmt.Printf("Move #%d from %c to %c.\n", disk, rod_names[from], rod_names[to])
}
最后是无堆栈空间的迭代版河内塔。(盘片数字愈小,尺寸愈小)
pub fn hanoi(disk_count: usize, a: char, b: char, c: char) {
let bc_swap = [1, 0, 4, 5, 2, 3];
let a2b_b2c_c2a = [3, 2, 5, 4, 0, 1];
let number_of_total_steps = 2f64.powf(disk_count as f64) as usize - 1;
let mut route = Vec::with_capacity(number_of_total_steps);
let mut disks = Vec::with_capacity(number_of_total_steps);
unsafe {
route.set_len(number_of_total_steps);
disks.set_len(number_of_total_steps);
}
let mut size = 1;
route[0] = 1;
disks[0] = 1;
for n in 2..=disk_count {
for e in route.iter_mut().take(size) {
*e = bc_swap[*e];
}
route[size] = 1;
disks[size] = n;
for i in 0..size {
route[size + i + 1] = a2b_b2c_c2a[route[i]];
}
unsafe {
copy_nonoverlapping(disks.as_ptr(), disks[size + 1..].as_mut_ptr(), size);
}
size <<= 1;
size += 1;
}
for (i, s) in route.into_iter().enumerate() {
let (rod_from, rod_to) = match s {
0 => (a, b),
1 => (a, c),
2 => (b, a),
3 => (b, c),
4 => (c, a),
_ => (c, b),
};
println!("Move #{} from {} to {}.", disks[i], rod_from, rod_to);
}
}
public static void hanoi(final int disk_count, final char a, final char b, final char c) {
final int[] bc_swap = new int[]{1, 0, 4, 5, 2, 3};
final int[] a2b_b2c_c2a = new int[]{3, 2, 5, 4, 0, 1};
final int number_of_total_steps = (int) Math.pow(2, disk_count) - 1;
final int[] route = new int[number_of_total_steps];
final int[] disks = new int[number_of_total_steps];
int size = 1;
route[0] = 1;
disks[0] = 1;
for (int i = 2; i <= disk_count; ++i) {
for (int j = 0; j < size; ++j) {
route[j] = bc_swap[route[j]];
}
route[size] = 1;
disks[size] = i;
for (int j = 0; j < size; ++j) {
route[size + j + 1] = a2b_b2c_c2a[route[j]];
}
System.arraycopy(disks, 0, disks, size + 1, size);
size <<= 1;
size += 1;
}
for (int i = 0; i < number_of_total_steps; ++i) {
final int s = route[i];
final char rod_from, rod_to;
switch (s) {
case 0:
rod_from = a;
rod_to = b;
break;
case 1:
rod_from = a;
rod_to = c;
break;
case 2:
rod_from = b;
rod_to = a;
break;
case 3:
rod_from = b;
rod_to = c;
break;
case 4:
rod_from = c;
rod_to = a;
break;
default:
rod_from = c;
rod_to = b;
}
System.out.printf("Move #%d from %c to %c.%n", disks[i], rod_from, rod_to);
}
}
function hanoi(diskCount: number, a: string, b: string, c: string) {
const bcSwap = [
1, 0, 4, 5, 2, 3,
];
const a2bB2cC2a = [
3, 2, 5, 4, 0, 1,
];
const numberOfTotalSteps = (2 ** diskCount) - 1;
const route = new Array<number>(numberOfTotalSteps);
const disks = new Array<number>(numberOfTotalSteps);
let size = 1;
route[0] = 1;
disks[0] = 1;
for (let i = 2;i <= diskCount;i++) {
for (let j = 0;j < size;j++) {
route[j] = bcSwap[route[j]];
}
route[size] = 1;
disks[size] = i;
for (let j = 0;j < size;j++) {
const index = size + j + 1;
route[index] = a2bB2cC2a[route[j]];
disks[index] = disks[j];
}
size <<= 1;
size += 1;
}
for (let i = 0;i < numberOfTotalSteps;i++) {
const r = route[i];
let rodFrom;
let rodTo;
switch (r) {
case 0:
rodFrom = a;
rodTo = b;
break;
case 1:
rodFrom = a;
rodTo = c;
break;
case 2:
rodFrom = b;
rodTo = a;
break;
case 3:
rodFrom = b;
rodTo = c;
break;
case 4:
rodFrom = c;
rodTo = a;
break;
default:
rodFrom = c;
rodTo = b;
}
console.log(`Move #${disks[i]} from ${rodFrom} to ${rodTo}.`);
}
}
func hanoi(disk_count int, a rune, b rune, c rune) {
bc_swap := [...]int{1, 0, 4, 5, 2, 3}
a2b_b2c_c2a := [...]int{3, 2, 5, 4, 0, 1}
number_of_total_steps := int(math.Pow(2.0, float64(disk_count))) - 1
route := make([]int, number_of_total_steps)
disks := make([]int, number_of_total_steps)
size := 1
route[0] = 1
disks[0] = 1
for i := 2; i <= disk_count; i++ {
for j := 0; j < size; j++ {
route[j] = bc_swap[route[j]]
}
route[size] = 1
disks[size] = i
for j := 0; j < size; j++ {
route[size+j+1] = a2b_b2c_c2a[route[j]]
}
copy(disks[size+1:], disks[:size])
size <<= 1
size += 1
}
for i, s := range route {
var rod_from, rod_to rune
switch s {
case 0:
rod_from = a
rod_to = b
case 1:
rod_from = a
rod_to = c
case 2:
rod_from = b
rod_to = a
case 3:
rod_from = b
rod_to = c
case 4:
rod_from = c
rod_to = a
default:
rod_from = c
rod_to = b
}
fmt.Printf("Move #%d from %c to %c.\n", disks[i], rod_from, rod_to)
}
}
利用盘片的输出规律来实现不用堆栈空间的河内塔迭代版函数
在实作出有输出盘片编号的河内塔程序后,可以试玩一下,会发现输出的盘片编号其实也有规律。
如果我们只让河内塔程序输出盘片编号,四个盘片的结果如下:
1 2 1 3 1 2 1 4 1 2 1 3 1 2 1
五个盘片的结果如下:
1 2 1 3 1 2 1 4 1 2 1 3 1 2 1 5 1 2 1 3 1 2 1 4 1 2 1 3 1 2 1
六个盘片的结果如下:
1 2 1 3 1 2 1 4 1 2 1 3 1 2 1 5 1 2 1 3 1 2 1 4 1 2 1 3 1 2 1 6 1 2 1 3 1 2 1 4 1 2 1 3 1 2 1 5 1 2 1 3 1 2 1 4 1 2 1 3 1 2 1
看出来了吗?这摆明就是一个数列嘛!而且可以找出以下公式来直接求得指定项数的值。
#{{{
a_n = \lfloor log_2{(n \text{ } XOR \text{ } (n + 1))} \rfloor + 1, n \in \mathbb{N^0}
}}}#
也就是说,我们先前利用「四步一循环」和「三步一循环」规律来实作的迭代版的河内塔函数,可以改成无堆栈空间的版本,只需要额外记录当下的所有盘片在哪个杆子上即可,而且也可以顺便将它们修改成以「盘片数字愈小,尺寸愈小」的方式来输出。
将「四步一循环」修改后的代码如下:
fn move_disk(disk_positions: &mut [char], disk: usize, to: char) {
println!("Move #{} from {} to {}.", disk + 1, disk_positions[disk], to);
disk_positions[disk] = to;
}
pub fn hanoi_iteratively(disk_count: usize, mut rod_from: char, mut rod_temp: char, mut rod_to: char) {
let mut disk_positions = vec![rod_from; disk_count];
if disk_count & 1 == 1 {
let temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
let end = 2f64.powf(disk_count as f64) as usize - 1;
let mut step = 1;
for i in 0..end {
let disk = ((i ^ (i + 1)) as f64).log2().floor() as usize;
match step {
1 => move_disk(&mut disk_positions, disk, rod_temp),
2 | 3 => move_disk(&mut disk_positions, disk, rod_to),
_ => {
if disk_positions[disk] == rod_from {
move_disk(&mut disk_positions, disk, rod_temp)
} else {
move_disk(&mut disk_positions, disk, rod_from)
}
let from = rod_from;
let temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
}
step += 1;
}
}
static void moveDisk(final char[] disk_positions, final int disk, final char to) {
System.out.printf("Move #%d from %c to %c.%n", disk + 1, disk_positions[disk], to);
disk_positions[disk] = to;
}
public static void hanoiIteratively(final int disk_count, char rod_from, char rod_temp, char rod_to) {
final char[] disk_positions = new char[disk_count];
Arrays.fill(disk_positions, rod_from);
if ((disk_count & 1) == 1) {
final char temp = rod_temp;
rod_temp = rod_to;
rod_to = temp;
}
final int end = (int) Math.pow(2, disk_count) - 1;
int step = 1;
for (int i = 0; i < end; ++i) {
final int disk = (int) Math.floor(Math.log(i ^ (i + 1)) / Math.log(2));
switch (step) {
case 1:
moveDisk(disk_positions, disk, rod_temp);
break;
case 2:
case 3:
moveDisk(disk_positions, disk, rod_to);
break;
case 4:
if (disk_positions[disk] == rod_from) {
moveDisk(disk_positions, disk, rod_temp);
} else {
moveDisk(disk_positions, disk, rod_from);
}
final char from = rod_from;
final char temp = rod_temp;
rod_from = rod_to;
rod_temp = from;
rod_to = temp;
step = 1;
continue;
}
++step;
}
}
function moveDisk(diskPositions: string[], disk: number, to: string) {
console.log(`Move #${disk + 1} from ${diskPositions[disk]} to ${to}.`);
diskPositions[disk] = to;
}
function hanoiIteratively(diskCount: number, rodFrom: string, rodTemp: string, rodTo: string) {
const diskPositions = new Array<string>(diskCount).fill(rodFrom);
if ((diskCount & 1) === 1) {
const temp = rodTemp;
rodTemp = rodTo;
rodTo = temp;
}
const end = (2 ** diskCount) - 1;
let step = 1;
for (let i = 0;i < end;i++) {
const disk = Math.floor(Math.log2(i ^ (i + 1)));
switch (step) {
case 1:
moveDisk(diskPositions, disk, rodTemp);
break;
case 2:
case 3:
moveDisk(diskPositions, disk, rodTo);
break;
case 4: {
if (diskPositions[disk] === rodFrom) {
moveDisk(diskPositions, disk, rodTemp);
} else {
moveDisk(diskPositions, disk, rodFrom);
}
const from = rodFrom;
const temp = rodTemp;
rodFrom = rodTo;
rodTemp = from;
rodTo = temp;
step = 1;
continue;
}
}
step += 1;
}
}
func moveDisk(disk_positions []rune, disk int, to rune) {
fmt.Printf("Move #%d from %c to %c.\n", disk+1, disk_positions[disk], to)
disk_positions[disk] = to
}
func hanoiIteratively(disk_count int, rod_from rune, rod_temp rune, rod_to rune) {
disk_positions := make([]rune, disk_count)
for i := 0; i < disk_count; i++ {
disk_positions[i] = rod_from
}
if disk_count&1 == 1 {
temp := rod_temp
rod_temp = rod_to
rod_to = temp
}
end := int(math.Pow(2.0, float64(disk_count))) - 1
step := 1
for i := 0; i < end; i++ {
disk := int(math.Floor(math.Log2(float64(i ^ (i + 1)))))
switch step {
case 1:
moveDisk(disk_positions, disk, rod_temp)
case 2, 3:
moveDisk(disk_positions, disk, rod_to)
case 4:
if disk_positions[disk] == rod_from {
moveDisk(disk_positions, disk, rod_temp)
} else {
moveDisk(disk_positions, disk, rod_from)
}
from := rod_from
temp := rod_temp
rod_from = rod_to
rod_temp = from
rod_to = temp
step = 1
continue
}
step++
}
}
将「三步一循环」修改后的代码如下:
fn move_disk(disk_positions: &mut [char], disk: usize, to: char) {
println!("Move #{} from {} to {}.", disk + 1, disk_positions[disk], to);
disk_positions[disk] = to;
}
fn move_between_rods(disk_positions: &mut [char], disk: usize, x: char, y: char) {
if disk_positions[disk] == x {
move_disk(disk_positions, disk, y);
} else {
move_disk(disk_positions, disk, x);
}
}
pub fn hanoi_iteratively(disk_count: usize, a: char, mut b: char, mut c: char) {
let mut disk_positions = vec![a; disk_count];
if disk_count & 1 == 1 {
let temp = b;
b = c;
c = temp;
}
let end = 2f64.powf(disk_count as f64) as usize - 1;
let mut step = 1;
for i in 0..end {
let disk = ((i ^ (i + 1)) as f64).log2().floor() as usize;
match step {
1 => move_between_rods(&mut disk_positions, disk, a, b),
2 => move_between_rods(&mut disk_positions, disk, a, c),
_ => {
move_between_rods(&mut disk_positions, disk, b, c);
step = 1;
continue;
}
}
step += 1;
}
}
static void moveDisk(final char[] disk_positions, final int disk, final char to) {
System.out.printf("Move #%d from %c to %c.%n", disk + 1, disk_positions[disk], to);
disk_positions[disk] = to;
}
static void moveBetweenRods(final char[] disk_positions, final int disk, final char x, final char y) {
if (disk_positions[disk] == x) {
moveDisk(disk_positions, disk, y);
} else {
moveDisk(disk_positions, disk, x);
}
}
public static void hanoiIteratively(final int disk_count, final char a, char b, char c) {
final char[] disk_positions = new char[disk_count];
Arrays.fill(disk_positions, a);
if ((disk_count & 1) == 1) {
final char temp = b;
b = c;
c = temp;
}
final int end = (int) Math.pow(2, disk_count) - 1;
int step = 1;
for (int i = 0; i < end; ++i) {
final int disk = (int) Math.floor(Math.log(i ^ (i + 1)) / Math.log(2));
switch (step) {
case 1:
moveBetweenRods(disk_positions, disk, a, b);
break;
case 2:
moveBetweenRods(disk_positions, disk, a, c);
break;
default:
moveBetweenRods(disk_positions, disk, b, c);
step = 1;
continue;
}
++step;
}
}
function moveDisk(diskPositions: string[], disk: number, to: string) {
console.log(`Move #${disk + 1} from ${diskPositions[disk]} to ${to}.`);
diskPositions[disk] = to;
}
function moveBetweenRods(diskPositions: string[], disk: number, x: string, y: string) {
if (diskPositions[disk] === x) {
moveDisk(diskPositions, disk, y);
} else {
moveDisk(diskPositions, disk, x);
}
}
function hanoiIteratively(diskCount: number, a: string, b: string, c: string) {
const diskPositions = new Array<string>(diskCount).fill(a);
if ((diskCount & 1) === 1) {
const temp = b;
b = c;
c = temp;
}
const end = (2 ** diskCount) - 1;
let step = 1;
for (let i = 0;i < end;i++) {
const disk = Math.floor(Math.log2(i ^ (i + 1)));
switch (step) {
case 1:
moveBetweenRods(diskPositions, disk, a, b);
break;
case 2:
moveBetweenRods(diskPositions, disk, a, c);
break;
case 3:
moveBetweenRods(diskPositions, disk, b, c);
step = 1;
continue;
}
step += 1;
}
}
func moveDisk(disk_positions []rune, disk int, to rune) {
fmt.Printf("Move #%d from %c to %c.\n", disk+1, disk_positions[disk], to)
disk_positions[disk] = to
}
func moveBetweenRods(disk_positions []rune, disk int, x rune, y rune) {
if disk_positions[disk] == x {
moveDisk(disk_positions, disk, y)
} else {
moveDisk(disk_positions, disk, x)
}
}
func hanoiIteratively(disk_count int, a rune, b rune, c rune) {
disk_positions := make([]rune, disk_count)
for i := 0; i < disk_count; i++ {
disk_positions[i] = a
}
if disk_count&1 == 1 {
temp := b
b = c
c = temp
}
end := int(math.Pow(2.0, float64(disk_count))) - 1
step := 1
for i := 0; i < end; i++ {
disk := int(math.Floor(math.Log2(float64(i ^ (i + 1)))))
switch step {
case 1:
moveBetweenRods(disk_positions, disk, a, b)
case 2:
moveBetweenRods(disk_positions, disk, a, c)
case 3:
moveBetweenRods(disk_positions, disk, b, c)
step = 1
continue
}
step++
}
}




