代码随想录算法训练营第三期day38-动态规划01

目录

1. T509：斐波那契数

1.1 版本Ⅰ、非压缩版

1.2 版本Ⅱ、压缩版

1.2.1 舍弃数组版

2. T70：爬楼梯

2.1 版本Ⅰ、非压缩版

2.2 版本Ⅱ、压缩版

 2.2.1 舍弃数组版

3. T746：使用最小花费爬楼梯

3.1 版本Ⅰ、全数组版

3.2 版本Ⅱ、压缩版

3.2.1 舍弃数组版

3.2.2 小数组版

---

1. T509：斐波那契数

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

F(0) = 0，F(1) = 1

F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

提示：

• 0 <= n <= 30

S：自己随手用递归敲了，然而没考虑到时间和空间复杂度：

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

• 时间复杂度：O(2^n)

• 空间复杂度：O(n)，算上了编程语言中实现递归的系统栈所占空间

看了题解后，发现还是动态规划好！

1.1 版本Ⅰ、非压缩版

C++：

    int fib(int n) {
        if (n <= 1) return n;// 无此行会导致数组访问越界【不理解】
        vector<int> dp(n + 1);
        // dp[0] = 0, dp[1] = 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];
    }

Java：

    public int fib(int n) {
        if (n <= 1) return n;// 不能缺
        // List<Integer> dp = new ArrayList<>();
        int[] dp = new int[n + 1];
        // dp[0] = 0, dp[1] = 1;//error，不像C++可以这样写
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; ++i) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

1.2 版本Ⅱ、压缩版

C++：

    int fib(int n) {
        if (n <= 1) return n;// 无此行 0->1
        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];
    }

Java：

    public int fib(int n) {
        if (n == 0) return 0;
        int[] dp = new int[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];
    }

1.2.1 舍弃数组版

也可以不用数组：

    public int fib(int n) {
        if (n == 0) return 0;
        int dp0 = 0, dp1 = 1;
        for (int i = 2; i <= n; ++i) {
            int sum = dp0 + dp1;
            dp0 = dp1;
            dp1 = sum;
        }
        return dp1;
    }

2. T70：爬楼梯

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

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

提示：

• 1 <= n <= 45

S：这道题自己本能地翻译成了返回所有不同方法的集合，属于是自己搞复杂了~

就我个人而言，本题的关键点和难点在于推理出递推公式。

• 结合Carl的题解，我个人的理解方式，或者说更喜欢的一种说法是：到达第 i 阶楼梯，所走的最后一步只有两种可能：1或2步
  • 那么在最后一步之前，对应的就是有 dp[i - 1] 或 dp[i - 2] 种方法爬到第i - 1 和 i - 2 阶楼梯
• 因此， 到达第i阶楼梯的方法数 dp[i] = dp[i - 1] + dp[i - 2]

2.1 版本Ⅰ、非压缩版

C++：

    int climbStairs(int n) {
        if (n <= 2) return n;// 下面直接对dp[2]操作了，防止空指针
        // vector<int> dp(n);
        vector<int> dp(n + 1);
        dp[1] = 1, dp[2] = 2;// dp[0]是多少无所谓
        for (int i = 3; i <= n; ++i) {
            dp[i] = dp[i - 2] + dp[i - 1];
        }
        return dp[n];
    }

Java：

    public int climbStairs(int n) {
        if (n <= 2) return n;
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; ++i) {
            dp[i] = dp[i - 2] + dp[i - 1];
        }
        return dp[n];
    }

2.2 版本Ⅱ、压缩版

C++：

    int climbStairs(int n) {
        if (n <= 2) return n;
        int dp[3];
        dp[1] = 1, dp[2] = 2;
        for (int i = 3; i <= n; ++i) {
            int temp = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = temp;
        }
        return dp[2];
    }

Java：

既然dp[0]实际上没有必要管，那可以舍弃dp[0]（实际上并不是太推荐这么做，这里只是随便试了一下）

    这样改变了数组元素及其索引对应的物理意义：上 i 阶楼梯有 dp[i] 种方法 -> 上 i 阶楼梯有 dp[i - 1] 种方法）

    public int climbStairs(int n) {
        if (n == 1) return 1;
        int[] dp = new int[2];
        dp[0] = 1;
        dp[1] = 2;
        for (int i = 2; i < n; ++i) {
            int temp = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = temp;
        }
        return dp[1];
    }

 2.2.1 舍弃数组版

C++：

    int climbStairs(int n) {
        if (n == 1) return 1;
        int dp1 = 1, dp2 = 2;
        for (int i = 3; i <= n; ++i) {
            int temp = dp1 + dp2;
            dp1 = dp2;
            dp2 = temp;
        }
        return dp2;
    }

Java：

    public int climbStairs(int n) {
        if (n <= 2) return n;
        int dp1 = 1, dp2 = 2;
        for (int i = 3; i <= n; ++i) {
            int temp = dp1 + dp2;
            dp1 = dp2;
            dp2 = temp;
        }
        return dp2;
    }

3. T746：使用最小花费爬楼梯

T746：给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

提示：

• 2 <= cost.length <= 1000

• 0 <= cost[i] <= 999

S：本题对于dp数组的定义非常重要，就我的理解，dp和题目提供的cost数组就相当于一进一出。

3.1 版本Ⅰ、全数组版

C++：

    int minCostClimbingStairs(vector<int>& cost) {
        int dp[cost.size() + 1];
        // dp[0] = cost[0], dp[1] = cost[1];// 对dp的定义不够理解！
        dp[0] = 0, dp[1] = 0;

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

Java：

    public int minCostClimbingStairs(int[] cost) {
        int[] dp = new int[cost.length + 1];
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= cost.length; ++i) {
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[dp.length - 1];
    }

• 时间复杂度：O(n)

• 空间复杂度：O(n)

还可以优化空间复杂度，因为dp[i]就是由前两位推出来的，那么也不用dp数组了。

3.2 版本Ⅱ、压缩版

3.2.1 舍弃数组版

C++：

    int minCostClimbingStairs(vector<int>& cost) {
        int dp0 = 0, dp1 = 0;
        for (int i = 2; i <= cost.size(); ++i) {
            int minCost = min(dp0 + cost[i - 2], dp1 + cost[i - 1]);
            dp0 = dp1;
            dp1 = minCost;
        }
        return dp1;
    }

Java：

    public int minCostClimbingStairs(int[] cost) {
        int dp0 = 0, dp1 = 0;
        for (int i = 2; i <= cost.length; ++i) {
            int minCost = Math.min(dp0 + cost[i - 2], dp1 + cost[i - 1]);
            dp0 = dp1;
            dp1 = minCost;
        }
        return dp1;
    }

3.2.2 小数组版

C++：

    int minCostClimbingStairs(vector<int>& cost) {
        int dp[2];
        dp[0] = 0, dp[1] = 0;
        for (int i = 2; i <= cost.size(); ++i) {
            int minCost = min(dp[0] + cost[i - 2], dp[1] + cost[i - 1]);
            dp[0] = dp[1];
            dp[1] = minCost;
        }
        return dp[1];
    }

Java：

    public int minCostClimbingStairs(int[] cost) {
        // if (cost.length == 2) return Math.min(cost[0], cost[1]);
        int[] dp = new int[2];
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= cost.length; ++i) {
            int minCost = Math.min(dp[0] + cost[i - 2], dp[1] + cost[i - 1]);
            dp[0] = dp[1];
            dp[1] = minCost;
        }
        return dp[1];
    }