跳台阶问题 + 变态跳台阶问题 解法(动态规划递归 + 非递归)

本文详细探讨了跳台阶问题及其变态版本,通过递归和非递归(迭代)方法来解决。介绍了动态规划的概念,分析了算法的时间复杂度,并给出了一种自底向上的动态规划解决方案。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、跳台阶问题

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

通过题目的描述,可以很清晰地看到,这就是一个Fibonacci数列。

递归实现:

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(s
<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]。
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值