[LeetCode] 70. 爬楼梯

Posted qiu_jiaqi

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[LeetCode] 70. 爬楼梯相关的知识,希望对你有一定的参考价值。

传送门:[LeetCode] 70. 爬楼梯

题目描述

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

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

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

示例 1:

输入: 2
输出: 2
解释: 有两种方法可以爬到楼顶。

  1. 1 阶 + 1 阶
  2. 2 阶

示例 2:

输入: 3
输出: 3
解释: 有三种方法可以爬到楼顶。

  1. 1 阶 + 1 阶 + 1 阶
  2. 1 阶 + 2 阶
  3. 2 阶 + 1 阶

分析与代码

  • 每次可以爬 1 或 2 个台阶,到达目的台阶要么是从前一个台阶爬 1 个台阶,要么从前两个台阶爬 2 个台阶;问题变为求前两个台阶的爬楼梯方法;很容易得出递推公式 F(n) = F(n-1) + F(n-2),和斐波那契数列一样。
  • 那就和 509. 斐波那契数 一样,不同的是这题数列从第二项开始,使用原斐波那契数列的第 2 项和第 3 项作为初始项。

解法一、递归(超时)

代码:

class Solution 
    public int climbStairs(int n) 
        if (n <= 2) 
            return n;
        
        return climbStairs(n - 1) + climbStairs(n - 2);
    

解法二、记忆化递归

  • 记忆化是一种优化技术,主要用于加快计算机程序的速度,方法是存储昂贵的函数调用的结果,并在相同的输入再次出现时返回缓存的结果。
  • 我们在之前递归的基础上,在计算之前判断是否已计算过,在计算完之后,先不要直接返回结果,而应先以当前 N 为 key,结果为 value 保存到 HashMap 中。

代码:

class Solution 
    Map<Integer, Integer> map = new HashMap<>();

    public int climbStairs(int n) 
        if (n <= 2) 
            return n;
        
        if (map.containsKey(n)) 
            return map.get(n);
        
        int result = climbStairs(n - 1) + climbStairs(n - 2);
        map.put(n, result);
        return result;
    

解法三、动态规划

  • 记忆化数组是自顶向下的,动态规划就把这个数组自底向上的生成。

代码:

class Solution 
    public int climbStairs(int n) 
        if (n <= 2) 
            return n;
        
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for (int i = 2; i < n; i++) 
            dp[i] = dp[i - 1] + dp[i - 2];
        
        return dp[n - 1];
    

解法四、优化动态规划

  • 要计算的状态只和前两个状态有关,只记录这两个状态,能进一步优化空间。

代码:

class Solution 
    public int climbStairs(int n) 
        if (n <= 2) 
            return n;
        
        int pre = 1, cur = 2;
        for (int i = 2; i < n; i++) 
            int next = pre + cur;
            pre = cur;
            cur = next;
        
        return cur;
    

解法五、常规矩阵乘法

\\[ \\beginmatrix \\left[ \\beginmatrix 1 & 0\\ 0 & 0 \\endmatrix \\right] \\left[ \\beginmatrix 1 & 1\\ 1 & 0 \\endmatrix \\right] = \\left[ \\beginmatrix 1+0 & 1+0\\ 0+0 & 0+0 \\endmatrix \\right] = \\left[ \\beginmatrix 1 & 1\\ 0 & 0 \\endmatrix \\right] \\endmatrix \\]

\\[ \\beginmatrix \\left[ \\beginmatrix 1 & 1\\ 0 & 0 \\endmatrix \\right] \\left[ \\beginmatrix 1 & 1\\ 1 & 0 \\endmatrix \\right] = \\left[ \\beginmatrix 1+1 & 1+0\\ 0+0 & 0+0 \\endmatrix \\right] = \\left[ \\beginmatrix 2 & 1\\ 0 & 0 \\endmatrix \\right] \\endmatrix \\]

\\[ \\beginmatrix \\left[ \\beginmatrix F_n & F_n-1\\ 0 & 0 \\endmatrix \\right] \\left[ \\beginmatrix 1 & 1\\ 1 & 0 \\endmatrix \\right] = \\left[ \\beginmatrix F_n+F_n-1 & F_n\\ 0 & 0 \\endmatrix \\right] = \\left[ \\beginmatrix F_n+1 & F_n\\ 0 & 0 \\endmatrix \\right] \\endmatrix \\]

  • 用矩阵的第一行记录两个数,再和\\(\\left[ \\beginmatrix 1 & 1\\\\ 1 & 0 \\endmatrix \\right]\\)相乘得出下一个矩阵。

代码:

class Solution 
    public int climbStairs(int n) 
        if (n <= 2) 
            return n;
        
        int[][] matrix =   2, 1 ,  0, 0  ;
        int[][] func =   1, 1 ,  1, 0  ;
        for (int i = 2; i < n; i++) 
            matrix = multiply(matrix, func);
        
        return matrix[0][0];
    

    private int[][] multiply(int[][] a, int[][] b) 
        int[][] c = new int[2][2];
        for (int i = 0; i < 2; i++) 
            for (int j = 0; j < 2; j++) 
                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
            
        
        return c;
    

解法六、优化矩阵乘法

  • 在上一个方法中,每次都是乘一个相同的矩阵;而同一数字多个相乘即幂运算,可以用二分法优化成快速幂,而矩阵也同样可以使用,先计算\\(M^n/2\\),然后在用矩阵相乘的公式即可。

    快速幂运算题目:[LeetCode] 50. Pow(x, n)

  • 矩阵的起始乘积不再是 1,而是单位矩阵\\(\\left[ \\beginmatrix 1 & 0\\\\ 0 & 1 \\endmatrix \\right]\\)

  • 在这题我们就要把矩阵初始为\\(\\left[ \\beginmatrix 1 & 1\\\\ 1 & 0 \\endmatrix \\right]\\),矩阵结构改为\\(\\left[ \\beginmatrix F_n & F_n-1\\\\ F_n-1 & F_n-2 \\endmatrix \\right]\\)

代码:

class Solution 
    public int climbStairs(int n) 
        if (n <= 2) 
            return n;
        
        int[][] matrix =   1, 1 ,  1, 0  ;
        int[][] result = pow(matrix, n);
        return result[0][0];
    

    private int[][] pow(int[][] matrix, int n) 
        int[][] result =   1, 0 ,  0, 1  ;
        for (int i = n; i > 0; i /= 2) 
            if ((i & 1) != 0) 
                result = multiply(matrix, result);
            
            matrix = multiply(matrix, matrix);
        
        return result;
    

    private int[][] multiply(int[][] a, int[][] b) 
        int[][] c = new int[2][2];
        for (int i = 0; i < 2; i++) 
            for (int j = 0; j < 2; j++) 
                c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
            
        
        return c;
    

解法七、斐波那契公式

\\[ F(n) = \\cfrac((\\cfrac1+\\sqrt[2]52)^n-(\\cfrac1-\\sqrt[2]52)^n)\\sqrt[2]5 \\]

因为是使用原斐波那契数列的第 2 项和第 3 项作为初始项,所以 n 需要 加 1。

代码:

class Solution 
    public int climbStairs(int n) 
        double sqrt5 = Math.sqrt(5);
        return (int) ((Math.pow((1 + sqrt5) / 2, n + 1) - Math.pow((1 - sqrt5) / 2, n + 1)) / sqrt5);
    

小结

这题和 509. 斐波那契数 是同一问题,只是初始项不同,这题的初始项是 1 和 2,且 n 不可取 0。

除了初始处理和 n 的边界处理有点不一样,方法还是一样的。


以上是关于[LeetCode] 70. 爬楼梯的主要内容,如果未能解决你的问题,请参考以下文章

「动态规划」LeetCode 70(爬楼梯)

LeetCode70——爬楼梯

leetcode70爬楼梯

LeetCode 题解 | 70. 爬楼梯

LeetCode70爬楼梯

LeetCode #70 爬楼梯