算法系列——动态规划1

509. 斐波那契数

class Solution {

public:

/*

    0 1 2 3 5 8 13 21....

    要算出dp[i]只需要dp[i-1],dp[i-2],可进行空间上的优化

    只需要定义一个两个空间的数组dp[2]:反复的进行更新

*/

    int fib(int n) {

        /*if(n<=1) return n;

        vector<int>dp(n+1);

        dp[0]=0;

        dp[1]=1;

        for(int i=2;i<=n;i++){

            dp[i]=dp[i-1]+dp[i-2];

        }

        return dp[n];

        */

        

        //优化：

        if(n<=1) return n;

        int dp[2];

        dp[0]=0;

        dp[1]=1;

        for(int i=2;i<=n;i++){

            int sum=dp[0]+dp[1];

            dp[0]=dp[1];

            dp[1]=sum;

        }

        return dp[1];

    }

};

70. 爬楼梯

class Solution {

public:

/*

    dp[i]:爬到第i层有多少种方法

    当爬到第i层时，只能从第i-1层爬一梯或i-2层爬2梯来，将这两种方法加起来即使爬到第i层的方法：

    dp[i]=dp[i-1]+dp[i-2];

    1 2 3 5 8 13 21....

*/

    int climbStairs(int n) {

        /*if(n<=1) return 1;

        vector<int>dp(n+1);

        dp[1]=1;

        dp[2]=2;

        for(int i=3;i<dp.size();i++){

            dp[i]=dp[i-1]+dp[i-2];

        }

        return dp[n];*/

        //优化：

        if(n<=1) return n;

        int dp[3];

        dp[1]=1;

        dp[2]=2;

        for(int i=3;i<=n;i++){

            int sum=dp[1]+dp[2];

            dp[1]=dp[2];

            dp[2]=sum;

        }

        return dp[2];

    }

};

746. 使用最小花费爬楼梯

class Solution {

public:

/*  

题目描述为：每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。

要么就是第一步不花费体力，要么就是最后一步不花费

    dp[i]:到达第i个台阶所花费的最小体力值

    cost  1   100   1   1   1   100   1   1   100   1

    index 0    1    2   3   4    5    6   7    8    9

    dp    1   100   2   3   3   103   4   5   104   6    

   最后一步不花费体力，第一步花费体力:所以定义数组dp数组大小就不用访问到第cost.size()，访问到cost.size()-1,所以定义数组大小为cost.size()就行,最后返回倒数第一层与倒数第二层的最小花费体力值

*/

    int minCostClimbingStairs(vector<int>& cost) {        

        int n=cost.size();

        vector<int>dp(n);

        dp[0]=cost[0];

        dp[1]=cost[1];

        for(int i=2;i<=n-1;i++){

            dp[i]=min(dp[i-1],dp[i-2])+cost[i];

        }

        return min(dp[n-2],dp[n-1]);

    }

};