爬楼梯问题是
一个经典的算法问题，涉及多种算法思想和优化技巧。以下是几种使用 C++ 解决
爬楼梯问题的方法：
### 暴力搜索
暴力搜索是最直接的方法，通过递归的方式列举出所有可能的
爬楼梯方式。但这种方法的时间复杂度较高，会有大量的重复计算。
```cpp
#include <iostream>
int climbStairsWithRecursive(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
return climbStairsWithRecursive(n - 1) + climbStairsWithRecursive(n - 2);
}
int main() {
std::cout << "请输入
楼梯阶数：" << std::endl;
int n;
std::cin >> n;
int m = climbStairsWithRecursive(n);
std::cout << m << std::endl;
return 0;
}
```
### 记忆化搜索
记忆化搜索是在暴力搜索的基础上，使用
一个数组来记录已经计算过的结果，避免重复计算，从而提高效率。
```cpp
#include <iostream>
#include <vector>
int climbStairsWithRecursive2(int n, std::vector<int>& memo) {
if (n == 1) return 1;
if (n == 2) return 2;
if (memo[n] != 0) return memo[n];
memo[n] = climbStairsWithRecursive2(n - 1, memo) + climbStairsWithRecursive2(n - 2, memo);
return memo[n];
}
int main() {
std::cout << "请输入
楼梯阶数：" << std::endl;
int n;
std::cin >> n;
std::vector<int> memo(n + 1, 0);
int b = climbStairsWithRecursive2(n, memo);
std::cout << b << std::endl;
return 0;
}
```
### 动态规划
动态规划是解决
爬楼梯问题的常用方法，通过定义状态和状态转移方程来求解。把爬 `n` 阶
楼梯的方法看做爬 `n - 1` 阶
楼梯和迈出的一步的方法或者 `n - 2` 阶
楼梯和迈出两步的方法之和 [^3]。
```cpp
#include <iostream>
#include <vector>
int climbStairsWithRecursive3(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
std::vector<int> dp(n + 1);
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
int main() {
std::cout << "请输入
楼梯阶数：" << std::endl;
int n;
std::cin >> n;
int c = climbStairsWithRecursive3(n);
std::cout << c << std::endl;
return 0;
}
```
### 动态规划空间优化
可以对动态规划的空间复杂度进行优化，由于状态转移只依赖于前两个状态，因此可以只使用两个变量来保存中间结果。
```cpp
#include <iostream>
int climbStairsOptimized(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
int first = 1;
int second = 2;
int third;
for (int i = 3; i <= n; i++) {
third = first + second;
first = second;
second = third;
}
return second;
}
int main() {
std::cout << "请输入
楼梯阶数：" << std::endl;
int n;
std::cin >> n;
int result = climbStairsOptimized(n);
std::cout << result << std::endl;
return 0;
}
```
### 三步问题（
爬楼梯拓展）
如果每次可以爬 1、2 或 3 步
楼梯，这就是
一个三步问题，与普通
爬楼梯问题类似，只是状态转移方程有所不同。
```cpp
#include <iostream>
#include <vector>
const int MOD = 1e9 + 7;
int waysToStep(int n) {
std::vector<int> dp(n + 1);
if (n == 1 || n == 2) return n;
if (n == 3) return 4;
dp[1] = 1;
dp[2] = 2;
dp[3] = 4;
for (int i = 4; i <= n; ++i) {
dp[i] = ((dp[i - 1] + dp[i - 2]) % MOD + dp[i - 3]) % MOD;
}
return dp[n];
}
int main() {
std::cout << "请输入
楼梯阶数：" << std::endl;
int n;
std::cin >> n;
int result = waysToStep(n);
std::cout << result << std::endl;
return 0;
}
```
### 最小花费
爬楼梯问题（
爬楼梯升级版）
如果
爬楼梯需要花费一定的体力，要求计算最小花费，这就是
爬楼梯的升级版问题。
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
class Solution {
public:
int minCostClimbingStairs(std::vector<int>& cost) {
int length = cost.size();
std::vector<int> sum(length);
sum[0] = cost[0];
sum[1] = cost[1];
for (int i = 2; i < length; i++) {
sum[i] = std::min(sum[i - 1], sum[i - 2]) + cost[i];
}
return std::min(sum[length - 1], sum[length - 2]);
}
};
int main() {
std::vector<int> cost = {1, 100, 1, 1, 1, 100, 1, 1, 100, 1};
Solution sol;
int result = sol.minCostClimbingStairs(cost);
std::cout << "最小花费: " << result << std::endl;
return 0;
}
```
本文探讨了一个经典的爬楼梯问题：如何用不同方法爬上n阶楼梯，每次只能爬1阶或2阶。文章通过分析得出了解决该问题的公式，即斐波那契数列，并提供了一段Python代码实现。
扫一扫
1356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
