递归:跳台阶问题

本文探讨了跳台阶问题的解决方法,从简单情况出发,分析得出与Fibonacci序列的关系,介绍了递归方法及其时间复杂度问题,提出了避免重复计算的改进方法,最终提供了快速计算第n项的公式,时间复杂度为O(1)。

本文转自:http://zhedahht.blog.163.com/blog/static/25411174200731844235261/

http://zhedahht.blog.163.com/blog/static/25411174200722991933440/

题目:一个台阶总共有n级,如果一次可以跳1级,也可以跳2级。求总共有多少总跳法,并分析算法的时间复杂度。

分析:这道题最近经常出现,包括MicroStrategy等比较重视算法的公司都曾先后选用过个这道题作为面试题或者笔试题。

首先我们考虑最简单的情况。如果只有1级台阶,那显然只有一种跳法。如果有2级台阶,那就有两种跳的方法了:一种是分两次跳,每次跳1级;另外一种就是一次跳2级。

现在我们再来讨论一般情况。我们把n级台阶时的跳法看成是n的函数,记为f(n)。当n>2时,第一次跳的时候就有两种不同的选择:一是第一次只跳1级,此时跳法数目等于后面剩下的n-1级台阶的跳法数目,即为f(n-1);另外一种选择是第一次跳2级,此时跳法数目等于后面剩下的n-2级台阶的跳法数目,即为f(n-2)。因此n级台阶时的不同跳法的总数f(n)=f(n-1)+(n-2)

我们把上面的分析用一个公式总结如下:

        /  1                          n=1
f(n)=      2                          n=2
        \  f(n-1)+f(n-2)               n>2

分析到这里,相信很多人都能看出这就是我们熟悉的Fibonacci序列。

  题目:定义 Fibonacci 数列如下:

        /  0                      n=0
f(n)=      1                      n=1
        \  f(n-1)+f(n-2)          n=2

输入n,用最快的方法求该数列的第n项。

分析:在很多C语言教科书中讲到递归函数的时候,都会用Fibonacci作为例子。因此很多程序员对这道题的递归解法非常熟悉,看到题目就能写出如下的递归求解的代码。

long long Fibonacci_Solution1(unsigned int n)
{
      int result[2] = {0, 1};
      if(n < 2)
            return result[n];

      return Fibonacci_Solution1(n - 1) + Fibonacci_Solution1(n - 2);
}

但是,教科书上反复用这个题目来讲解递归函数,并不能说明递归解法最适合这道题目。我们以求解f(10)作为例子来分析递归求解的过程。要求得f(10),需要求得f(9)f(8)。同样,要求得f(9),要先求得f(8)f(7)……我们用树形结构来表示这种依赖关系

                  f(10)
               /        \
            f(9)         f(8)
          /     \       /    \
       f(8)     f(7)  f(7)   f(6)
      /   \     /   \
 
   f(7)  f(6)  f(6) f(5)

我们不难发现在这棵树中有很多结点会重复的,而且重复的结点数会随着n的增大而急剧增加。这意味这计算量会随着n的增大而急剧增大。事实上,用递归方法计算的时间复杂度是以n的指数的方式递增的。大家可以求Fibonacci的第100项试试,感受一下这样递归会慢到什么程度。在我的机器上,连续运行了一个多小时也没有出来结果。

其实改进的方法并不复杂。上述方法之所以慢是因为重复的计算太多,只要避免重复计算就行了。比如我们可以把已经得到的数列中间项保存起来,如果下次需要计算的时候我们先查找一下,如果前面已经计算过了就不用再次计算了。

更简单的办法是从下往上计算,首先根据f(0)f(1)算出f(2),在根据f(1)f(2)算出f(3)……依此类推就可以算出第n项了。很容易理解,这种思路的时间复杂度是O(n)


long long Fibonacci_Solution2(unsigned n)
{
      int result[2] = {0, 1};
      if(n < 2)
            return result[n];

      long long  fibNMinusOne = 1;
      long long  fibNMinusTwo = 0;
      long long  fibN = 0;
      for(unsigned int i = 2; i <= n; ++ i)
      {
            fibN = fibNMinusOne + fibNMinusTwo;

            fibNMinusTwo = fibNMinusOne;
            fibNMinusOne = fibN;
      }

       return fibN;
}

最快的计算方法是找到公式,根据公式计算出第n项,时间复杂度为O(1)。


<think>根据引用内容,青蛙台阶问题是一个经典的递归问题,其规律与斐波那契数列类似。问题描述如下: - 一只青蛙一次可以上1级台阶,也可以上2级台阶(有些问题中还可以3级,但这里以最常见的两种法为例)。 - 求该青蛙上一个n级的台阶总共有多少种法。 通过引用[3]和引用[5]的分析,我们可以得到: - 当n=1时,只有1种法(1级)。 - 当n=2时,有2种法(一次2级,或分两次每次1级)。 - 当n>2时,青蛙的最后一步有两种选择:1级或2级。如果最后一步1级,则前面的法为f(n-1);如果最后一步2级,则前面的法为f(n-2)。因此,总法数为f(n) = f(n-1) + f(n-2)。 这实际上就是斐波那契数列的递推关系,只是初始值不同: - 斐波那契数列:F(0)=0, F(1)=1, F(2)=1, F(3)=2, ... - 青蛙台阶1或2级):f(1)=1, f(2)=2, f(3)=3, f(4)=5, ... 即从f(1)开始就是斐波那契数列的移位。 因此,我们可以用递归方法实现,但需要注意递归的终止条件。 C++递归实现代码: ```cpp #include <iostream> int jumpWays(int n) { if (n <= 0) return 0; // 没有台阶法为0 if (n == 1) return 1; // 1级台阶只有1种法 if (n == 2) return 2; // 2级台阶有2种法 return jumpWays(n-1) + jumpWays(n-2); // 对于n>2 } int main() { int n; std::cout << "请输入台阶: "; std::cin >> n; std::cout << "法总数: " << jumpWays(n) << std::endl; return 0; } ``` ### 代码说明: 1. **递归终止条件**: - $n \leq 0$:返回0,因为台阶数非正时没有法。 - $n=1$:返回1(只有一种法:1级)。 - $n=2$:返回2(两种法:连续两次1级,或一次2级)。 2. **递归关系**: - 当 $n>2$ 时,法数等于上 $n-1$ 级台阶法数加上上 $n-2$ 级台阶法数,即: $$f(n) = f(n-1) + f(n-2)$$ 3. **示例**: - 输入 $n=3$,输出 $3$(法:1+1+1, 1+2, 2+1)。 - 输入 $n=4$,输出 $5$(法:1+1+1+1, 1+1+2, 1+2+1, 2+1+1, 2+2)。 ### 注意事项: 1. **时间复杂度**:$O(2^n)$,指数级,效率较低。当 $n$ 较大时(如 $n>40$)会非常慢。 2. **重复计算问题**:递归过程中会重复计算很多子问题(如计算 $f(5)$ 时需要计算 $f(4)$ 和 $f(3)$,而计算 $f(4)$ 时又会计算 $f(3)$ 和 $f(2)$)。 3. **栈溢出风险**:递归深度过大可能导致栈溢出。 ### 优化建议: 1. **记忆化递归**:使用数组或哈希表存储已计算的子问题结果,避免重复计算,将时间复杂度降为 $O(n)$。 2. **动态规划**:使用循环自底向上计算,避免递归开销(见引用[4])。 > 如果青蛙一次可以1级、2级或3级台阶(如引用[2]所述),则递推关系变为 $f(n) = f(n-1) + f(n-2) + f(n-3)$,终止条件需增加 $n=3$ 的情况($f(3)=4$)[^2]。 §§相关问题§§ 1. 如何用动态规划优化青蛙台阶问题? 2. 青蛙台阶问题的时间复杂度如何分析? 3. 青蛙台阶问题与斐波那契数列有什么联系和区别? 4. 如果青蛙一次可以任意阶(1~n级),法总数是多少? 5. 记忆化递归在C++中如何实现? [^1]: 青蛙台阶问题递归关系与斐波那契数列类似。 [^2]: 当青蛙一次可以1、2或3级时,递推关系变为三项和。</think>### C++递归实现青蛙台阶问题 青蛙台阶问题是一个经典的递归问题,其核心思想是通过分解问题为更小的子问题来解决。根据台阶数的不同,青蛙的法遵循特定的规律: #### 问题分析 1. **台阶数与法关系**: - 当 $n=1$ 时:只有1种法(直接1级)[^3] - 当 $n=2$ 时:有2种法(1+1 或 直接2级)[^3] - 当 $n=3$ 时:有3种法(1+1+1, 1+2, 2+1)[^1] - 当 $n>3$ 时:法数 = $n-1$ 级的方法 + $n-2$ 级的方法[^5] 2. **递推公式**: $$f(n) = \begin{cases} 1 & n=1 \\ 2 & n=2 \\ f(n-1) + f(n-2) & n>2 \end{cases}$$ #### C++递归实现代码 ```cpp #include <iostream> int frogJump(int n) { // 基础情况处理 if (n <= 0) return 0; // 无效台阶数 if (n == 1) return 1; // 只有1种法 [^3] if (n == 2) return 2; // 有2种法 [^3] // 递归关系:f(n) = f(n-1) + f(n-2) [^5] return frogJump(n - 1) + frogJump(n - 2); } int main() { int steps; std::cout << "请输入台阶: "; std::cin >> steps; std::cout << "法总数: " << frogJump(steps) << std::endl; return 0; } ``` #### 代码说明 1. **递归终止条件**: - $n=1$:返回1(直接1级) - $n=2$:返回2(1+1 或 直接2级) 2. **递归关系**: $$f(n) = \text{frogJump}(n-1) + \text{frogJump}(n-2)$$ 表示最后一步可以选择1级(剩余 $n-1$ 级)或2级(剩余 $n-2$ 级)[^5] 3. **示例输出**: ```bash 请输入台阶: 3 法总数: 3 # (1+1+1, 1+2, 2+1) ``` #### 复杂度与优化 1. **时间复杂度**:$O(2^n)$,存在大量重复计算 2. **优化建议**: - 使用记忆化存储(缓存已计算结果) - 改用动态规划(时间复杂度 $O(n)$)[^4] - 对于能3级的情况,递推式改为 $f(n) = f(n-1) + f(n-2) + f(n-3)$[^2] > 此实现直观展示了递归思想,但实际应用中应考虑优化方案以避免指数级时间复杂度[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值