Java implementa recursivamente el juego Torre de Hanoi

1. Reglas

La Torre de Hanoi es un problema matemático clásico que consiste en mover una pila de placas desde un pilar inicial a otro pilar objetivo mientras lo hace con la ayuda de un pilar intermedio. Las siguientes son las reglas de la Torre de Hanoi:

1. Hay tres pilares, llamados pilar inicial, pilar de meta y pilar intermedio.
2. Inicialmente, todas las placas se apilan en la columna inicial en orden de mayor a menor.
3. Sólo se puede mover un plato a la vez y sólo se pueden colocar platos más pequeños encima de platos más grandes.
4. Durante el movimiento, las placas se pueden almacenar temporalmente con la ayuda de la columna intermedia.
5. El objetivo es mover todas las placas de la columna inicial a la columna de destino.

2. Implementación del código

(1) Ideas

Según las reglas, el problema de la Torre de Hanoi se puede resolver mediante recursividad. Los pasos de la solución recursiva son los siguientes:

1. Si solo hay una placa, muévala directamente de la columna inicial a la columna de destino.
2. Si hay varias placas, mueva las placas superiores excepto la inferior desde la columna de inicio a la columna del medio (con la ayuda de la columna de meta).
3. Mueva la placa más inferior de la columna inicial a la columna de destino.
4. Mueva la placa que se movió previamente al poste central desde el poste central al poste objetivo (con la ayuda del poste inicial).

Al repetir los pasos anteriores, todas las placas se pueden mover desde la columna inicial a la columna objetivo, completando el movimiento de la Torre de Hanoi.

Tenga en cuenta que la solución al problema de las Torres de Hanoi tiene una complejidad temporal exponencial, por lo que puede llevar mucho tiempo cuando se trata de una gran cantidad de placas.

(2) Código

public class MyClass {
    
    
   public static void main(String[] args){
    
    
       // 3 是塔的层数，a 是起始柱子，b 是中间柱，c 是目标柱
       tower(3, 'a', 'b', 'c');
   }

   //递归
   public static void tower(int num, char a, char b, char c) {
    
    
       //只有一个盘子时，直接将它从起始柱移动到目标柱
       if (num == 1) {
    
    
           System.out.println(a + " --> " + c);
       } else {
    
    
           //将除了最底下盘子以外的所有盘子视为一个，移动到中间柱
           tower(num - 1, a, c, b);
           //将最底下的盘子移动到目标柱
           System.out.println(a + " --> " + c);
           //将除了最底下盘子以外的所有盘子视为一个，移动到目标柱
           tower(num - 1, b, a, c);
       }
   }

}

(3) Complejidad

• Complejidad del tiempo: O(2^n), donde nestá el número de placas.
• Complejidad espacial: O(n). Debido a que la llamada recursiva generará la sobrecarga de la pila recursiva, la profundidad de la recursividad es n-1.

3. Resultados de ejecución

a --> c
a --> b
c --> b
a --> c
b --> a
b --> c
a --> c