“青蛙跳台阶”问题

1、“青蛙跳台阶”问题的总体描述：

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个n级的台阶总共有多少种跳法？

2、文字分析：

青蛙跳一个台阶有一种跳法；

青蛙跳两个台阶有两种跳法：（1）、一次跳2级台阶；（2）、一次条1级台阶，一共跳2次；

青蛙跳三个台阶有三种跳法：它第一跳无非两种情况：跳1阶和跳2阶，

若跳了1阶，则还剩2阶，那么就是跳2个台阶的情况，有两种跳法；

若跳了2阶，则还剩1阶，那么就是跳1级台阶的情况；

综上，跳3个台阶时相当于先分类再相加前两种情况；

同理，青蛙跳四个台阶有五种跳法：它第一跳也无非两种情况：跳1阶和跳2阶，

若跳了1阶，则还剩3阶，那么就是跳3个台阶的情况；

若跳了2阶，则还剩2阶，那么就是跳2个台阶的情况；

即跳4个台阶=跳2个台阶+跳3个台阶。

再来，青蛙跳五个台阶有八种跳法：它第一跳也无非两种情况：跳1阶和跳2阶，

若跳了1阶，则还剩4阶，那么就是跳4个台阶的情况；

若跳了2阶，则还剩3阶，那么就是跳3个台阶的情况；

即跳5个台阶=跳3个台阶+跳4个台阶。

........

综上，跳n个台阶的种数可以等于跳n-1个台阶的种数加上跳n-2个台阶的种数。

这让我不禁联想到斐波那契数列：1、1、2、3、5、8、13、21、34、……

“青蛙跳台阶”问题的答案似乎就是斐波那契数列去掉第一个数得到的数列。

那么，我们是不是就可以用“斐波那契数列”的算法来求解这个问题呢？

3、代码：

在C语言中，可以用多种方式来实现斐波那契数列。

（1）、递归，（2）、非递归，（3）、数组。

（1）、递归：可能造成栈溢出

#include<stdio.h>
    int Fib(int n)
    {
        if(n==1||n==2)
        return 1;
        else
        {
        return Fib(n - 1) + Fib(n - 2);
        }
        return 0;
    }
    int main()
    {
        int n = 0;
        scanf("%d", &n);
        int ret = Fib(n);
        printf("%d\n", ret);
        return 0;
    }

（2）、非递归:

 #include<stdio.h>
    int Fib(int n)
    {
        int a = 1;
        int b = 1;
        int tmp = 1;
         while (n>2)
            {
                tmp = a + b;
                a = b;
                b = tmp;
                n--;
            }
            return tmp;
    }
    int main()
    {
        int n = 0;
        int ret = 0;
        scanf("%d", &n);
        ret = Fib(n);
        printf("该数的斐波那契数列为%d", ret);
        return 0;
    }

（3）、数组:

 #include<stdio.h>
    int Fib(int n)
    {
        int i;
        int arr[100] = {0,1,1};
        for (i = 2; i <= n; i++)//从第一项开始
        {
            arr[i] = arr[i - 1] + arr[i - 2];    
        }
        return arr[n];
    }
    int main()
    {
        int n;
        scanf("%d", &n);
        printf("%d", Fib(n));
        return 0;
    }

先不急，我们先用递归的思路来写一个代码：

#include<stdio.h>
int Jump_steps(int i)
{
    if (i == 1)
    {
        return 1;//当只有一层台阶时直接返回1
    }
     if (i == 2)
    {
        return 2;//当只有2层台阶时直接返回2
    }
    //也可以直接写成：
    /*if（i==1||i==2）
    {
        return i;
    }*/
     if (i > 2)
     {
         return Jump_steps(i - 1) + Jump_steps(i - 2);
     }
}
int main()
{
    int n = 0;
    scanf("%d", &n);
    int num = Jump_steps(n);
    printf("%d\n", num);
    return 0;
}

但是，这就引出了一个问题，依靠递归计算的问题似乎效率非常低下，它会不断地计算一些重复的数。

例如：要求第六个数，就需要计算三遍第三个数：

因此，为了优化解法、提高效率，我们不得不考虑到另一种方法——循环：

#include<stdio.h>
int Jump(int n)
{
    int a = 1;
    int b = 2;
    int c = 0;
    while (n > 2)
    {
        c = a + b;
        a = b;
        b = c;
        n--;
    }
    return c;
    if (n <= 2)
    {
        return n;
    }
}
int main()
{
    int a;
    printf("青蛙需要跳几个台阶：\n");
    scanf("%d", &a);
    printf("青蛙将会有几种跳法：\n");
    printf("%d ", Jump(a));
    return 0;
}

类比斐波那契数列，还可以使用数组的方法：

#include<stdio.h>
int Jump(int n)
{
    int i;
    int arr[100] = { 1,1,2};
    for (i = 2; i <= n; i++)
    {
        arr[i] = arr[i - 1] + arr[i - 2];
    }
    return arr[n];
}
int main()
{
    int n;
    printf("青蛙要跳几个台阶:");
    scanf("%d", &n);
    printf("一共有%d种跳法", Jump(n));
    return 0;
}

综上是"青蛙跳台阶"问题的几种解法，欢迎大家补充。

我不禁又想到，如果这个问题延申一下，变成： 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶......甚至可以一次跳上n级台阶！求该青蛙跳上一个n级的台阶总共有多少种跳法？这是否涉及到了阶乘的思想呢？