汉诺塔

经典汉诺塔

当有两个盘子的时候整个移动过程就是

A->B

A->C

B->C

当有多个盘子的时候，可将n-1个盘子作为整体。整个就相当于一个两个盘子的情况，而对于作为整体看待的n-1个盘子就采用递归。

public void Hanoi(int num, String A, String B, String C){
        if(num == 1)
            System.out.println(A + " -> " + C);
        else{
            Hanoi(num - 1,A,C,B);
            System.out.println(A + " -> " + C);
            Hanoi(num - 1,B,A,C);
            
        }        
    }

汉诺塔的一点变形:

参考http://blog.csdn.net/qq120848369/article/details/5472267

多组测试数据，每组两行。第一行是n(1<=n<=32)，表示有多少个盘第二行由n个数字1,2,3组成的数字串，
第一个数表示最大的盘在第几根针上，第二个数表示次大的盘在第几根针上，第n个数表示最小的盘在第几根针上，
输入的n为0的时候结束
输出：
全部移动到第三根针上所需要的最少步数
样例输入：
3
111
3
321
0
样例输出：
7
2

/**
     * 计算汉诺塔步数（变型）
     * 汉诺塔的递推公式为 an = 2* an-1 +1 完成整个汉诺塔移动需要将第n个盘移动一次
     * 并将n-1个盘移动两次
     * @param iCount
     * @param iAim
     * @return
     */
    int hanoi(int iCount, int iAim)//将第 i个盘子移到目标盘需要的步数
    {
        if(iCount == 0)
            return 0;
        else if(iDisk[iCount] == iAim)//如果第i个盘已经在目标针上，只需要计算i-1个盘就行
            return hanoi(iCount - 1 , iAim);
        else//如果第n个盘不在目标针上，就要将n-1个盘移到目前针和目标针之外的另一个针上
               //并且加上将第n个盘移到目标针，再将n-1个盘移到目标针上
            return hanoi(iCount - 1, 6 - iDisk[iCount] - iAim) + 1 + sHanoi[iCount - 1];    
        
    }

public static void main (String args[]){
        HanoiMain hanoiMain = new HanoiMain();
        //经典汉诺塔
        //hanoiMain.Hanoi(3, "A", "B", "C");
        hanoiMain.sHanoi =new int [33];
        
        int iAim =3;
        for(int i = 1; i <=32 ; i++){
            hanoiMain.sHanoi[i] = hanoiMain.sHanoi[i-1] *2 +1;//汉诺塔步数递推公式为
                                                                                                        //an = 2 * an-1 +1
        }
        
        int cinArray[] = {1,1,1,1} ;//输入序列
        
        for(int i = 0; i <cinArray.length ; i++){
                hanoiMain.iDisk[i] = cinArray[i];
        }
        System.out.println("所需步数为: " + hanoiMain.hanoi(cinArray.length, iAim));
        
        
    }