hanio 塔和递规的理解。

java:
没什么好说，问题分解为子问题的组合。子问题必须到某个规模是可解。
看最早自己的思路，基本ok。就是要简洁处理下。
重要的是这部

movehan(source, des, temp,count-1);
int obj=source.pop();
LSLog.printLine(obj+":"+source.tipString+ " move "+des.tipString+".", 1);
des.push(obj);
要注意，这行代码上面的movehan（xxx）是已经完成的动作。不是假设性动作。而是确定性动作。所以才可以source.pop();

public static class hanluota
    {
        public static void test()
        {
            MyStack<Integer> source=new MyStack<Integer>();
            MyStack<Integer> temp=new MyStack<Integer>();
            MyStack<Integer> des=new MyStack<Integer>();
            
            source.push(4);
            source.push(3);
            source.push(2);
            source.push(1);
            
            source.tipString="A";
            temp.tipString="B";
            des.tipString="C";
            
            movehan(source, temp, des, source.size());
        }
        
        //分解问题:s(n-1)->temp.   t(n)->des, temp(n-1)->s.
        public static void movehan(MyStack<Integer> source,MyStack<Integer> temp,MyStack<Integer> des,int count)
        {
            //基本问题
            if(count==1)
            {
                int obj= source.pop();
                des.push(obj);
                LSLog.printLine(obj+":"+source.tipString+ " move "+des.tipString+".", 1);
            }
            else {
                movehan(source, des, temp,count-1);
                int obj=source.pop();
                LSLog.printLine(obj+":"+source.tipString+ " move "+des.tipString+".", 1);
                des.push(obj);
                movehan(temp, source, des,count-1);
            }
        }
    }

//递规很好理解,但是初看hanoi的时候,总没有理所当然的感觉.
//那应该是对递规根本还没理解吧.仔细想了下.有点总结.


后来翻到 <<数据结构>> 112页,原来hanio的程序在这里解释了.基本和自己的思考结果一致.只是书中更简练.
书中提到的接口一致,不知道包不包括,函数可以运行的条件. 又想了想,可能真的不需要去关心函数可以运行的条件,
只要关心函数接口一致,但保证子问题和确定组合中的,确定是真的确定.也就是这个move(n,x,y),只要你n-1移走了.n 一定可以移动.
赫赫,好像稍微更清楚了一点.

//先从我们熟悉的 从1加到100.这种递规分析起把.

int main()
{
//int answer=qestion(100);
//printf("%d",answer);

qestion2(3,'x','y','z');

}



//------------------基本思路:分解问题，减低次数， 直到某次问题不再是问题，让总问题变成 [新问题]和[确定]的组合

//[总问题]，[新问题]，[次小问题]，[最小问题(不是问题)]
//总问题分解，并减少难度
//分解为[确定]和[新问题]组合， 而新问题本质和老问题一样，并且满足老问题的解决方案的条件。
//确定[新问题]达到某个问题时，里面的问题，按照规定，是确定解。这个某个问题就是[次小问题]。
//里面的问题就是[最小问题]，[最小问题]，按照规定，是确定解。
//所以只要[最小问题]是确定解，依赖最小问题的次小问题（[确定]和[最小问题]组合）一定有解，以至[总问题]。
//ps:（[新问题]，[次小问题]本质一样。只是次小问题中的问题不再是问题）





//总问题 1+2+3+...+100= ?
//分解并降低难度，总问题分解为
//    [1+2+3+...99]  + [100]
//    [新问题]       + [确定]
//    总问题的目的是累加，基本没有条件，新问题不存在条件缺失。
//到达 1+2这个问题时候，1+2是次小问题，而里面的问题1，不再是问题。1是最小问题。
int qestion(int n)
{
    int answer=0;
    if(n>1)
    {
        answer=n+qestion(n-1);//问题分解，减低难度 分解为 [确定] +[问题]
    }

//    (2==n)//次小问题。  因为[新问题]，[次小问题]本质一样，只是方便确定最小问题而已，注释掉。
//    {
//        answer=2+qestion(1);//qestion(1) 是最小问题，按照常识:1+question(1-1)，是确定解为1。
//    }

    if(1==n)//最小问题。
    {
        answer=1;//1+question(1-1) 按规定是1。直接写确定，终止递规。
    }
    return answer;
}

//总问题 从x移动n块盘到y。用z中转。
//分解并降低难度，总问题分解为
//   [从x移动n-1快盘到z，用y中转]  +[从x移动n到y]  +  [从z移动n-1快盘到y，x中转]
//   [新问题]                      + [确定]        +  [新问题]。
//   总问题的条件是，y和z是空柱子，第一个新问题,y,z都空满足同样条件，第二个新问题x空柱子。y柱子有第n盘。但根据游戏规则。n最大,y可以看作空柱子。
//   之后所有的新问题都满足条件。因为n-i块在柱子中间跳来跳去的时候，3个柱子存留的盘是>=n-i+1的，可以看作 空柱子。
//到达 n=2,只有2个盘的时候，发现这个次小问题 [从x移动2-1快盘到z，用y中转]  +[从x移动n到y]  +  [从z移动2-1快盘到y，x中转]
//   里面的所有问题都不在是问题，因为n-1,变成了2-1.
//   [从x移动2-1快盘到z，用y中转]。原来需要中转的问题变成了，移动1块盘的问题了。移动1块不再是 问题了。

void qestion2(int n,char x,char y,char z)
{

    if(n>1)//问题分解，减低难度.分解为 [问题] +[确定] +[问题]
    {
        qestion2(n-1,x,z,y);
        move(n,x,y);
        qestion2(n-1,z,y,x);
    }

//    (2==n)
//    {
//        ////次小问题。因为 qestion2(2-1,x,z,y)，不是问题了。看看他的意思，移动一块盘，从x到z。v做中转，一块盘不需要中专了，这不是问题。
//        qestion2(2-1,x,z,y);//所以 qestion2(2-1,x,z,y)。当n等于1的时候，由问题改为确定方案move(1,x,z);
//        move(2,x,y);//
//        qestion2(2-1,z,y,x);//move(1,z,y)
//    }

    if(1==n)
    {
        move(1,x,y);//question2(1,x,y,z),按常识，移动一块，相当于move(1,x,y)，直接确定。
    }
}

void move(int n,char x,char y)
{
    printf("[%d]f:%c->%c
",n,x,y);
}