【剑指offer】跳台阶问题 + 变态跳台阶问题解法（动态规划递归 + 非递归） C++实现-优快云博客

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
通过题目的描述，可以很清晰地看到，这就是一个Fibonacci数列。
思路:
a.如果两种跳法，1阶或者2阶，那么假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1);
b.假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)
c.由a\b假设可以得出总跳法为: f(n) = f(n-1) + f(n-2)
d.然后通过实际的情况可以得出：只有一阶的时候 f(1) = 1 ,只有两阶的时候可以有 f(2) = 2
e.可以发现最终得出的是斐波那契数列的另一种形式；
f. 当前台阶的跳法总数=当前台阶后退一阶的台阶的跳法总数+当前台阶后退二阶的台阶的跳法总数

递归实现：

unsigned long long solution(int stageNum)
{
    //定义递归出口
    if(stageNum <= 0)
        return 0;
    else if(1 == stageNum)
        return 1;
    else if(2 == stageNum)
        return 2;
 
    return solution(stageNum - 1) + solution(stageNum - 2);
}

这是最低级的做法，耗费的时间是输入规模的指数级别的。可以加入计算缓存来提高递归速度。
采用自顶向下的动态规划。

//自顶向下的动态规划
unsigned long long solution(int stageNum)
{
static unsigned long long Counter[101] = {0};
if(0 != Counter[stageNum])
return Counter[stageNum];

//定义递归出口
if(stageNum <= 0)
    return 0;
else if(1 == stageNum)
    return Counter[1] = 1;
else if(2 == stageNum)
    return Counter[2] = 2;

Counter[stageNum] = solution(stageNum - 1) + solution(stageNum - 2);
return Counter[stageNum];

}
这个算法可以得到线性时间复杂度的结果。

非递归实现（迭代实现）：

//自底向上动态规划

//自底向上的动态规划
unsigned long long solution(int number)
{
//题目保证 number 最大为100
static unsigned long long Counter[101] = {0};
Counter[1] = 1;
Counter[2] = 2;
static int calculatedIndex = 2;

if(number <= calculatedIndex)
    return Counter[number];

//防止下标越界
if(number > 100)
    number = 100;

for(int i = calculatedIndex + 1; i <= number; i++)
{
    Counter[i] = Counter[i - 1] + Counter[i - 2];
}
calculatedIndex = number;
return Counter[number];

}

二、变态跳台阶问题
题目描述：一个台阶总共有n级，如果一次可以跳1级，也可以跳2级……也可以跳n级。求总共有多少总跳法，并分析算法的时间复杂度。

分析：用Fib(n)表示跳上n阶台阶的跳法数。如果按照定义，Fib(0)肯定需要为0，否则没有意义。但是我们设定Fib(0) = 1；n = 0是特殊情况，通过下面的分析就会知道，强制令Fib(0) = 1很有好处。ps. Fib(0)等于几都不影响我们解题，但是会影响我们下面的分析理解。

当n = 1 时，只有一种跳法，即1阶跳：Fib(1) = 1;

当n = 2 时，有两种跳的方式，一阶跳和二阶跳：Fib(2) = 2;

到这里为止，和普通跳台阶是一样的。

当n = 3 时，有三种跳的方式，第一次跳出一阶后，对应Fib(3-1)种跳法；第一次跳出二阶后，对应Fib(3-2)种跳法；第一次跳出三阶后，只有这一种跳法。Fib(3) = Fib(2) + Fib(1)+ 1 = Fib(2) + Fib(1) + Fib(0) = 4;

当n = 4时，有四种方式：第一次跳出一阶，对应Fib(4-1)种跳法；第一次跳出二阶，对应Fib(4-2)种跳法；第一次跳出三阶，对应Fib(4-3)种跳法；第一次跳出四阶，只有这一种跳法。所以，Fib(4) = Fib(4-1) + Fib(4-2) + Fib(4-3) + 1 = Fib(4-1) + Fib(4-2) + Fib(4-3) + Fib(4-4) 种跳法。

当n = n 时，共有n种跳的方式，第一次跳出一阶后，后面还有Fib(n-1)中跳法；第一次跳出二阶后，后面还有Fib(n-2)中跳法…第一次跳出n阶后，后面还有 Fib(n-n)中跳法。Fib(n) = Fib(n-1)+Fib(n-2)+Fib(n-3)+…+Fib(n-n) = Fib(0)+Fib(1)+Fib(2)+…+Fib(n-1)。

通过上述分析，我们就得到了通项公式：

             Fib(n) =  Fib(0)+Fib(1)+Fib(2)+.......+ Fib(n-2) + Fib(n-1)

因此，有 Fib(n-1)=Fib(0)+Fib(1)+Fib(2)+…+Fib(n-2)

两式相减得：Fib(n)-Fib(n-1) = Fib(n-1) =====》 Fib(n) = 2*Fib(n-1) n >= 3

这就是我们需要的递推公式：Fib(n) = 2*Fib(n-1) n >= 3

//自底向上的动态规划

//自底向上的动态规划
//变态N阶跳

unsigned long long solution(int number)
{
    //题目保证 number 最大为100
    static unsigned long long Counter[101] = {0};
    Counter[0] = 1;
    Counter[1] = 1;
    Counter[2] = 2;
    static int calculatedIndex = 2;
 
    if(number <= calculatedIndex)
        return Counter[number];
 
    //防止下标越界
    if(number > 100)
        number = 100;
 
    for(int i = calculatedIndex + 1; i <= number; i++)
    {
        Counter[i] = 2 * Counter[i - 1];
    }
    calculatedIndex = number;
    return Counter[number];
}