8/15 动态规划——爬楼梯、最小花费爬楼梯

爬楼梯

根据题目，可以知道，通过n阶到楼顶的方法数是到n-1阶的方法数加上到n-2阶的方法数。
很容易想到递归的方法，以及斐波那切数列：f(n)=f(n-1)+f(n-2)。

递归：

class Solution {
public:
    int climbStairs(int n) {
        if(n==2)
        return 2;
        if(n==1)
        return 1;      
      
        return climbStairs(n-2)+climbStairs(n-1);
    }
};

直接使用递归的方法，提交显示超时，显然这种方法会有很多重复计算，时间复杂度达到O(2ⁿ)。

记忆递归：

这是官方答案中记忆递归的方法，可以减少重复计算。
这种方法将已经计算出来的爬n级台阶的方法存放在数组memo里

class Solution {
public:
    int climbStairs(int n) {
        int *memo= new int[n+1];
        return climbStairsMemo(n,memo);
    }
public:
    int climbStairsMemo(int n,int memo[]){
        if(memo[n]>0)   //这个位置大于0说明曾经计算过，结果存在memo[n]里
            return memo[n];
            
        if(n==1)
            memo[n] = 1 ;
            else if(n==2)
                memo[n] = 2 ;
                else memo[n]=climbStairsMemo(n-1,memo)+climbStairsMemo(n-2,memo) ;  //递归调用自身

        return memo[n];
    }
};

在这里我声明这个数组的时候，用 int memo[ ] 报错了，后来改成 int *memo 就没问题了。

滚动数组

因为n的结果由n-1和n-2处得到，我们可以通过维护几个常量，把空间复杂度优化成O(1)。

class Solution {
public:
    int climbStairs(int n) {
        int p = 0, q = 0, r = 1;
        for(int i = 1 ;i <= n; i++){
            p = q;
            q = r;
            r = p + q ; 
        }
    return r;
    }
};

循环执行n次，时间复杂度为O(n)。

矩阵快速幂

这个的代码部分还没有实现

最小花费爬楼梯

这题的翻译有些不清楚，原文是：Once you pay the cost, you can either climb one or two steps.

与简单的爬楼梯相似，这题也存在一个递归关系，就是f[i] = cost[i] + min(cost[i-1],cost[i-2]) 。

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int c1 = cost[0];
        int c2 = cost[1];
        int N = cost.size();
        for (int i = 2; i < N; ++i) {
            int c3 = min(c1, c2) + cost[i];
            c1 = c2;
            c2 = c3;
        }
        return min(c1, c2); //到达顶部之前到最后一个或者倒数第二个都可以
    }
};