Ackerman 函数的解法
1.定义

    ack(m,n) =  n+1                     m = 0
    ack(m,n) = ack(m-1,1)            m!=0  n = 0
    ack(m,n) = ack(m-1,n-1)         m!=0  n!=0

2.示例
     ack(3,0) = (2,1) 
                 = (1,(2,0))
                 = (1,(1,1))
                 = (1,(0,(1,0)))
                 = (1,(0,(0,1))
                 = (1,(0,2))
                 = (1,3)
                 = (0,(1,2))
                 =(0,(0,(1,1))
                 ...
                 =(0,(0,3))
                 ...
                 = 5  

3.复杂性分析
 待解决,m>5后复杂度极高。


4.最简单的递归解法
//按照函数的递归定义即可

    int ack(int m, int n)
    {
         if (m == 0)
          return n+1;

         if (n == 0)
          return ack(m-1, 1);

         return ack(m-1, ack(m,n-1));

    }

5.去掉递归,用栈保存信息
/*
 *  n = 0 的时候往下递归其实只有一个递归分支,无需保留信息,可以用循环取代的
 *  而 对于 m!=0 && n!=0 的情况 注意到是一个迭代递归
 *  这其中 注意 我们用到 ack(m,n-1)的返回值作为 ack(m-1,x)的值
 *  事实上只需要m入栈,使得我们在进入到 ack(m,n-1)后最后能够返回出来计算 ack(m-1,x) x = ack(m,n-1)
 */

下面给出 带 goto 和不带 goto 语句的两种解法
int ack_goto(int m, int n)
{
int result;
stack<int> stk;

start:
if (m == 0)
{
result = n+1;
if (stk.empty())
{
goto end;
else
{
goto qiantao;
}
}
else if (n == 0)
{
m = m-1;
n = 1;
goto start;
}
else
{
m = m;
n = n-1;
stk.push(m);   //为了保留当期信息,只需保留m等待 右面嵌套返回结果继续
goto start;
qiantao:
m = stk.top();
stk.pop();
m = m-1;
n = result;
goto start;
}


end:
return result;
}



//机械式的对递归程序的用栈标准的非递归翻译
int ack_norec(int m, int n)
{
stack<int> stk;

stk.push(m);

while (!stk.empty())
{
m = stk.top();
stk.pop();
if (m == 0)
{
n = n+1;

}
else if (n == 0)
{
m = m-1;
n = 1;
stk.push(m);
}
else
{
m = m;
n = n-1;
stk.push(m-1);
stk.push(m);
}
}

return n;

}

5.对于以上基于定义用递归或是用栈消除递归的做法,有没有可能优化呢?
   对于示例 ack(3,0) 可以注意到 ack(1,1)出现了两次,对于上面的解法,ack(1,1)也就被计算了两次。
   事实上我们可以记录已经做好的中间结果,避免重复的递归,也就是所谓的剪枝。

    5.1递归加剪枝
        const int mMax = 5;
        const int nMax = 1000000;
        int ackV[mMax][nMax];
        bool got[mMax][nMax];       //注意全部初始为false

        int ack2(int m, int n)
        {
    if (m > mMax || n > nMax)
    {
cout << "error input too large" << endl;
exit(1);
    }
    if (got[m][n] == true)
return ackV[m][n];

    if (m == 0)
return n+1;
    if (n == 0 )
return ack2(m-1,1);

    ackV[m][n] = ack2(m-1,ack2(m,n-1));
    got[m][n] = true;
    return ackV[m][n];
        }
     
    5.2非递归算法的优化
         int ack_norec2(int m, int n)
        {
            if (m > mMax || n > nMax)
    {
cout << "error input too large" << endl;
exit(1);
    }

    stack<int> stk;
    stack<int> stk2;
    int result;
    bool flag = 0;

    stk.push(m);

    while (!stk.empty())
    {
                     if (n > nMax)
            {
        cout << "error input too large" << endl;
        exit(1);
            }
    m = stk.top();
    stk.pop();
   
    if (flag == 1)
    {
    if (got[m+1][stk2.top()] == false)
    {
        ackV[m+1][stk2.top()] = n;
    got[m+1][stk2.top()] = true;
    }
    stk2.pop();
    flag = 0;
    }
    if (got[m][n] == true)
    {
    n = ackV[m][n];   //退出口
            flag = 1;          //尽管不需要记录这个结果了但因为n已经被Push了要出栈
    continue;
    }

    if (m == 0)
    {
    n = n+1;          //退出口
    flag = 1;

    }
    else if (n == 0)
    {
    m = m-1;
    n = 1;
    stk.push(m);
    }
    else
    {
    m = m;
    n = n-1;
    stk.push(m-1);
    stk2.push(n);
    stk.push(m);
    }
        }

    return n;
        }

    
6.动态规划,记录前面的结果,空间换时间