爬楼梯问题是一个经典的算法问题，涉及多种算法思想和优化技巧。以下是几种使用 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 climbStairsWithRecursive
2(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] = climbStairsWithRecursive
2(n -
1, memo) + climbStairsWithRecursive
2(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 = climbStairsWithRecursive
2(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;
}
```
扫一扫
1920
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
