动态规划是前一个状态推导过来的，贪心是局部最优解。

class Solution {
public:
    int fib(int n) {
        int a=0;
        int b=1;
        int res=0;
        if(n==1) return 1;
        for(int i=2;i<=n;i++){
            res=a+b;
            a=b;
            b=res;
        }
        return res;
    }
};

可以由前面状态推出后面状态，是动态规划。由于始终只要后面两个数，得出新的数。所以不需要数组保存，而是用O(1)的空间就可以了。

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

        }
        return dp[n];
    }
};

 

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

我定义dp[i]为取当前代价条件下最小代价，为了能到顶部，所以cost后面加一个0，表示顶端。