1步2步走台阶

这篇博客探讨了如何使用动态规划方法解决走台阶问题。通过递归和循环两种方式实现,其中循环法在效率上优于递归。博客分析了问题的规律,即每个台阶的方法数是前两个台阶方法数之和,给出了简洁的代码实现。

目录

题目

一次走一步或者两步走完台阶,一共要多少种方法
在这里插入图片描述

分析

从上图可以看到规律,到第n个台阶时,要么从n-1台阶走一步到达,要么从n-2个台阶走两步到达,即前一台阶和前两台阶走法的和,用公式表达:f(n)=f(n-1)+f(n-2)

解题

方法1
递归,由于每次都要完全计算,层层计算,台阶增多时间复杂度指数增加,效率低下

static int f(int n) {
    if (n == 1) {
        return 1;
    }
    if (n == 2) {
        return 2;
    }
    return f(n - 1) + f(n - 2);
}

方法2
循环,算一遍

static int f(int n) {
    int[] total = new int[n + 1];
    total[1] = 1;
    total[2] = 2;
    for (int i = 3; i <= n; i++) {
        total[i] = total[i - 1] + total[i - 2];
    }
    return total[n];
}

方法3
循环,算一遍

static int f(int n) {
    if (n == 1 || n == 2) {
        return n;
    }
    int one = 1;
    int two = 2;
    int sum = 0;
    for (int i = 3; i <= n + 1; i++) {
        sum = one + two;
        one = two;
        two = sum;
    }
    return sum;
}
走k台阶问题是一个经典的动态规划问题,通常的变种是:给定一个楼梯有`n`阶,每次可以走`1`到`k`,求到达第`n`阶楼梯的总方法数。这个问题可以通过递归、记忆化递归或动态规划来解决。 ### 动态规划解法 动态规划的核心思想是定义一个状态数组`dp[i]`,表示到达第`i`阶楼梯的方法数。状态转移方程为: $$ dp[i] = dp[i-1] + dp[i-2] + \cdots + dp[i-k] $$ 其中,`dp[0] = 1`作为初始条件(表示站在地面,还没有走任何台阶的情况)。 #### C++实现代码如下: ```cpp #include <iostream> #include <vector> using namespace std; int countWays(int n, int k) { vector<int> dp(n + 1, 0); dp[0] = 1; // 初始条件 for (int i = 1; i <= n; ++i) { for (int j = 1; j <= k && j <= i; ++j) { dp[i] += dp[i - j]; } } return dp[n]; } int main() { int n = 10; // 台阶总数 int k = 3; // 每次可以走1到k cout << "总方法数: " << countWays(n, k) << endl; return 0; } ``` ### 递归解法 递归方法是直接根据问题定义来实现,但这种方法在`n`较大时效率较低,因为它会重复计算很多子问题。递归的终止条件是: - 如果 `n == 0`,返回 `1`(表示一种走法)。 - 如果 `n < 0`,返回 `0`(表示无效走法)。 #### C++实现代码如下: ```cpp #include <iostream> using namespace std; int countWaysRecursive(int n, int k) { if (n < 0) return 0; if (n == 0) return 1; int ways = 0; for (int i = 1; i <= k; ++i) { ways += countWaysRecursive(n - i, k); } return ways; } int main() { int n = 10; // 台阶总数 int k = 3; // 每次可以走1到k cout << "总方法数: " << countWaysRecursive(n, k) << endl; return 0; } ``` ### 优化方法:记忆化递归 为了避免重复计算,可以使用记忆化技术,将已经计算过的子问题结果存储起来,避免重复计算。 #### C++实现代码如下: ```cpp #include <iostream> #include <vector> using namespace std; int countWaysMemo(int n, int k, vector<int>& memo) { if (n < 0) return 0; if (n == 0) return 1; if (memo[n] != -1) return memo[n]; int ways = 0; for (int i = 1; i <= k && i <= n; ++i) { ways += countWaysMemo(n - i, k, memo); } memo[n] = ways; return ways; } int countWays(int n, int k) { vector<int> memo(n + 1, -1); return countWaysMemo(n, k, memo); } int main() { int n = 10; // 台阶总数 int k = 3; // 每次可以走1到k cout << "总方法数: " << countWays(n, k) << endl; return 0; } ``` ### 时间复杂度分析 - **动态规划解法**:时间复杂度为 $ O(n \cdot k) $,空间复杂度为 $ O(n) $。 - **递归解法**:时间复杂度为 $ O(k^n) $,空间复杂度为 $ O(n) $。 - **记忆化递归解法**:时间复杂度为 $ O(n \cdot k) $,空间复杂度为 $ O(n) $。 ### 优化思路 为了进一步优化空间复杂度,可以使用滑动窗口技巧,只保留最近的`k`个状态,而不是整个数组。这种方法将空间复杂度降低到 $ O(k) $。 #### C++实现代码如下: ```cpp #include <iostream> #include <vector> using namespace std; int countWaysOptimized(int n, int k) { vector<int> dp(n + 1, 0); dp[0] = 1; for (int i = 1; i <= n; ++i) { for (int j = 1; j <= k && j <= i; ++j) { dp[i] += dp[i - j]; } } return dp[n]; } int main() { int n = 10; // 台阶总数 int k = 3; // 每次可以走1到k cout << "总方法数: " << countWaysOptimized(n, k) << endl; return 0; } ``` ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值