爬楼梯

本文探讨了使用递归和斐波那契数列两种算法解决爬楼梯问题的具体实现。递归方法通过缓存避免重复计算,而斐波那契法则利用动态规划思想,实现了高效求解。

递归解法:

class Solution:
    def climbStairs(self, n: int) -> int:
        cache = {}
        return self.climb(n, cache)
    def climb(self, n: int, cache):
#基本情况是0,1,2
        if n == 0:
            return 0
        elif n == 1:
            return 1
        elif n == 2:
            return 2
        elif n in cache:
            return cache[n]
        else:
            cache[n] = self.climb(n - 2, cache) + self.climb(n - 1, cache)
            return cache[n]

方法就是每次调用climb的n-2和n-1两种情况,直到为基本情况

斐波那契法:

n层的所有情况即为n-1和n-2两种,即x_{n} = x_{n-1}+x_{n-2},转换为斐波那契数列的计算:

class Solution:
    def climbStairs(self, n: int) -> int:
        result = [0,1,2]
        len_re = 3
        if n < len_re:
            return result[n]
        else:
            for i in range(3, n + 1):
                temp = result[-1] + result[-2]
                result[-2] = result[-1]
                result[-1] = temp
        return result[-1]
        

 

爬楼梯问题是一个经典的算法问题,涉及多种算法思想和优化技巧。以下是几种使用 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; } ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值