汉诺塔问题

【题目】

给定一个整数n，代表汉诺塔游戏中从小到大放置的n个圆盘，假设开始时所有的圆盘都放在左边的柱子上，想按照汉诺塔游戏的要求把所有的圆盘都移动到右边的柱子上。实现函数打印最优移动轨迹。

【举例】

n=1，打印：
move from left to right
n=2，打印：
move from left to mid
move from left to right
move from mid to right

【代码】

    public static void main(String[] args) {
        hanoi(1);
        System.out.println("---------");
        hanoi(2);
        System.out.println("---------");
        hanoi(3);

//      move from left to right
//      ---------
//      move from left to mid
//      move from left to right
//      move from mid to right
//      ---------
//      move from left to right
//      move from left to mid
//      move from right to mid
//      move from left to right
//      move from mid to left
//      move from mid to right
//      move from left to right
    } 

    //汉诺塔问题
    public static void hanoi(int n){
        if(n>0){
            func(n,"left","mid","right");
        }
    }

    private static void func(int n, String from, String mid,String to) {
        if(n==1){
            System.out.println("move from "+from+" to "+to);
        }else{
            func(n-1,from,to,mid);//第一步：1-i从left移动到mid
            func(1,from,mid,to);//第二步：i从left移到right
            func(n-1,mid,from,to);//第三步：1-i从mid移到right
        }
    }

【进阶题目】

给定一个整型数组arr，其中只含有1、2和3，代表所有圆盘目前的状态，1代表左柱，2代表中柱，3代表右柱，arr[i]的值代表第i+1个圆盘的位置。比如arr[3,3,2,1]代表第1、2个圆盘在右柱上，第3个圆盘在中柱上，第4个圆盘在左柱上。如果arr代表的状态是最优移动轨迹过程中出现的状态，返回arr这种状态是最优移动轨迹中的第几个状态。如果arr代表的状态不是最优移动轨迹过程中出现的状态，返回-1.

【举例】

arr[1,1].两个圆盘都在左柱上，即初始状态，返回0.
arr[2,1].第1个圆盘在中柱上，第2个圆盘在左柱上，这个状态是最优移动轨迹中的第1步，返回1.
arr[3,3].两个圆盘都在右柱上，即2个圆盘最终的状态，是第3步，返回3.
arr[2,2].2个圆盘都在中柱上，不会出现的状态，返回-1.

【进阶要求】

时间复杂度O(N)，额外空间复杂度O(1)

【代码】

    public static void main(String[] args) {
        System.out.println(step1(new int[]{1,1}));//0
        System.out.println(step2(new int[]{1,1}));
        System.out.println(step1(new int[]{2,1}));//1
        System.out.println(step2(new int[]{2,1}));
        System.out.println(step1(new int[]{3,3}));//3
        System.out.println(step2(new int[]{3,3}));
        System.out.println(step1(new int[]{2,2}));//-1
        System.out.println(step2(new int[]{2,2}));
    }
    //汉诺塔进阶问题
    //方法1：递归，时间复杂度O(N),但递归函数需要函数栈，额外空间复杂度O(N)
    public static  int step1(int[] arr){
        if(arr==null||arr.length==0){
            return -1;
        }
        return process(arr,arr.length-1,1,2,3);
    }


    private static int process(int[] arr, int i, int from, int mid, int to) {
        if(i==-1){
            return 0;
        }
        if(arr[i]!=from && arr[i]!=to){//盘i在中柱上，不可能的状态
            return -1;
        }
        if(arr[i]==from){//盘i在左柱上，步骤1没有完成，继续考察前i-1的状态
            return process(arr,i-1,from,to,mid);
        }else{//盘i在右柱上，起码走了2^(i-1)步，继续考察前i-1，将其从mid移到to
            int rest=process(arr,i-1,mid,from,to);
            if(rest==-1){
                return -1;
            }
            return (1<<i)+rest;
        }
    }

    //方法2：非递归,额外空间复杂度O(1)
    public static int step2(int[] arr){
        if(arr==null || arr.length==0){
            return -1;
        }
        int from=1;
        int mid=2;
        int to=3;
        int tmp=0;
        int res=0;
        int i=arr.length-1;
        while(i>=0){
            if(arr[i]!=from && arr[i]!=to){
                return -1;
            }
            if(arr[i]==to){//i在to上，已经到第3步，剩余i-1盘将从mid->to
                res+=1<<i;
                tmp=from;
                from=mid;
            }else{//i在from上，第1步还没结束，剩余i-1盘将从from->mid
                tmp=to;
                to=mid;
            }
            mid=tmp;
            i--;
        }
        return res;
    }