19 - 爬楼梯问题

1. 爬楼梯

这道题和斐波那契数列一样，使用动态规划来解决

• 版本一

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return n; // 因为下面直接对dp[2]操作了，防止空指针
        vector<int> dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { // 注意i是从3开始的
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

时间复杂度O(n)，空间复杂度O(n)

• 版本二

这道题其实都是当前状态依赖前两个状态，可以做空间上的优化

class Solution {
public:
    int climbStairs(int n) {
        int arr[] = {1, 2};
        if(n <= 2) return arr[n - 1];
        for(int i = 3; i <= n; ++i){
            arr[1] += arr[0];
            arr[0] = arr[1] - arr[0];
        }
        return arr[1];
    }
};

时间复杂度O(n)，空间复杂度O(1)
如果这道题目改成可以爬1或2或3个台阶，问有多少种不同的方法可以爬到楼顶？
同样地当前状态依赖的是前三个状态，可以用递归/动态规划，因为递归会重复计算，所以使用动态规划，就不难写出如下代码

class Solution {
public:
    int climbStairs(int n) {
        int arr[] = { 1,2,4 };
		if (n <= 3) return arr[n - 1];
		for (int i = 4; i <= n; i++) {
			arr[2] += arr[1] + arr[0];
			arr[1] = arr[2] - arr[1] - arr[0];
			arr[0] = arr[2] - arr[1] - arr[0];
		}
		return arr[2];
    }
};

2. 爬楼梯的最小成本

使用动态规划来做

• 版本一
  状态转移方程为：dp[i] = min(dp[i-2] + cost[i-2], dp[i-1] + cost[i-1])

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size() + 1);
        dp[0] = 0; // 默认第一步都是不花费体力的
        dp[1] = 0;
        for (int i = 2; i <= cost.size(); i++) {
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[cost.size()];
    }
};

时间复杂度O(n)，空间复杂度O(n)

• 版本二

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int arr[] = {0, 0};
        int i = 2;
        for(; i <= cost.size(); ++i){
            int tmp = arr[1];
            arr[1] = min(arr[1] + cost[i - 1], arr[0] + cost[i - 2]);
            arr[0] = tmp;
        }
        return arr[1];
    }
};

时间复杂度O(n)，空间复杂度O(1)

进阶：打印经过的路径

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
		int size = cost.size();
			vector<int> dp(size + 1);
			vector<int> path(size + 1);//记录路径
			dp[0] = 0; 
			dp[1] = 0;
			for (int i = 2; i <= cost.size(); i++) {
				if (dp[i - 1] + cost[i - 1] < dp[i - 2] + cost[i - 2]) {
					dp[i] = dp[i - 1] + cost[i - 1];
					path[i] = i - 1;
				}
				else {
					dp[i] = dp[i - 2] + cost[i - 2];
					path[i] = i - 2;
				}
			}
			int i = size;
			stack<int> s;
			while (i != 0) {
				s.push(path[i]);
				i = path[i];
			}
			while (!s.empty()) {
				cout << s.top() << " ";
				s.pop();
			}
			return dp[size];
	}
};