动态规划：入门系列

LeetCode509. 斐波那契数

https://leetcode-cn.com/problems/fibonacci-number/

斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给你 n ，请计算 F(n) 。

输入：2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i]为第i个数的斐波那契数值

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

题目已经把状态转移方程直接给我们了：dp[i] = dp[i - 1] + dp[i - 2];

3.思考初始状态

题目中把初始状态也直接给我们了：dp[0] = 0, dp[1] = 1

4.自底向上计算得到最优解

        for (int i = 2; i <= n; ++i)
        {
            dp[i] = dp[i - 1] + dp[i - 2];
        }

5.思考是否可以进行空间的优化

可以仅维护两个数值，不需要记录整个序列。

        int p = 0, q = 1, r;
        for (int i = 2; i <= n; ++i)
        {
            r = p + q;
            p = q;
            q = r;
        }

代码

class Solution {
public:
    //动态规划
    /*int fib(int n) 
    {
        if (n == 0 || 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];
    }*/

    //优化
    /*int fib(int n) 
    {
        if (n == 0 || n == 1)
        {
            return n;
        }

        int p = 0, q = 1, r;
        for (int i = 2; i <= n; ++i)
        {
            r = p + q;
            p = q;
            q = r;
        }

        return q;
    }*/

    //递归
     int fib(int n) 
    {
        if (n == 0 || n == 1)
        {
            return n;
        }
        else
        {
            return fib(n - 1) + fib(n - 2);
        }
    }
};

LeetCode70. 爬楼梯

https://leetcode-cn.com/problems/climbing-stairs/

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

**注意：**给定 n 是一个正整数。

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i]表示爬到第i层楼梯的方法数

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

从dp[i]的定义可以看出，dp[i] 可以有两个状态推出来。

首先是dp[i - 1]，上i - 1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶就是dp[i]。

还有就是dp[i - 2]，上i - 2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶不就是dp[i]了么。

那么dp[i]就是 dp[i - 1]与dp[i - 2]之和。

所以：dp[i] = dp[i - 1] + dp[i - 2]

3.思考初始状态

dp[0] = 1, dp[1] = 1

4.自底向上计算得到最优解

        for (int i = 2;i <= n;++i)
        {
            dp[i] = dp[i - 1] + dp[i - 2];
        }

5.思考是否可以进行空间的优化

可以仅维护两个数值，不需要记录整个序列。

        int p = 1, q = 1, r;
        for (int i = 2;i <= n;++i)
        {
            r = p + q;
            p = q;
            q = r;
        }

代码

class Solution 
{
public:
    //动态规划
    /*int climbStairs(int n) 
    {
        vector<int> dp(n + 1);
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2;i <= n;++i)
        {
            dp[i] = dp[i - 1] + dp[i - 2];
        }

        return dp[n];
    }*/

    //优化
    int climbStairs(int n)
    {
        int p = 1, q = 1, r;
        for (int i = 2;i <= n;++i)
        {
            r = p + q;
            p = q;
            q = r;
        }

        return q;
    }
}

LeetCode746. 使用最小花费爬楼梯

https://leetcode-cn.com/problems/min-cost-climbing-stairs/

数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。

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

请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。

输入：cost = [10, 15, 20]
输出：15
解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。

思路

1.思考状态：找出最优解的性质，明确状态表示什么

dp[i]表示爬上第i个台阶所花费的最少体力

2.思考状态转移方程：大问题的最有解如何由小问题的最优解得到

从dp[i]的定义可以看出，dp[i] 可以有两个状态推出来：从dp[i]的定义可以看出，dp[i] 可以有两个状态推出来。显然选择较小的，所以：dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]

注意这里为什么是加cost[i]，而不是cost[i-1]或cost[i-2]，因为题目中说了：每当你爬上一个阶梯你都要花费对应的体力值

3.思考初始状态

题目说：在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。

所以：dp[0] = cost[0], dp[1] = cost[1]

4.自底向上计算得到最优解

        for (int i = 2; i < sz; ++i)
        {
            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
        }

5.思考是否可以进行空间的优化

可以仅维护两个数值，不需要记录整个序列。

        int p = cost[0], q = cost[1], r;
        for (int i = 2; i < sz; ++i)
        {
            r = min(p, q) + cost[i];
            p = q;
            q = r;
        }

代码

class Solution 
{
public:
    //动态规划
    /*int minCostClimbingStairs(vector<int>& cost) 
    {
        auto sz = cost.size();

        vector<int> dp(sz);
        dp[0] = cost[0];
        dp[1] = cost[1];
        for (decltype(sz) i = 2; i < sz; ++i)
        {
            dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
        }

        return min(dp[sz - 1], dp[sz - 2]);
    }*/

    //优化
    int minCostClimbingStairs(vector<int>& cost)
    {
        auto sz = cost.size();

        int p = cost[0], q = cost[1], r;
        for (decltype(sz) i = 2; i < sz; ++i)
        {
            r = min(p, q) + cost[i];
            p = q;
            q = r;
        }

        return min(p, q);
    }
};