代码随想录算法训练营第32天｜leetcode

1.509. 斐波那契数 - 力扣（LeetCode）

思路1:常规五步走

    int fib(int N)
    {
        if (N <= 1)
            return N;
        vector<int> dp(N + 1);//dp数组的含义是第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];
    }

思路2:优化,仅开辟两个数组空间就够了

int fib(int 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];
    }

2.70. 爬楼梯 - 力扣（LeetCode）

思路：首先定义dp数组含义，然后初始化，然后构造递推方程。

int fib(int 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];
    }

优化：

    int climbStairs(int 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];
    }

3.746. 使用最小花费爬楼梯 - 力扣（LeetCode）

思路：

    int minCostClimbingStairs(vector<int> &cost)
    {
        if (cost.size() == 2)
            return min(cost[0], cost[1]);
        int dp[cost.size() + 1]; // dp[i]表示到达第i个台阶的最小花费,cost[i]表示第i个台阶向上爬的花费 ，所以dp大小比cost大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()];
    }