5、华为OD机试算法题——跳台阶

地址：跳台阶_牛客题霸_牛客网

 一、递归 

示例代码：

    public int jumpFloor(int target) {
        if (target == 1) {
            return 1;
        } else if (target == 2) {
            return 2;
        } else {
            return jumpFloor(target - 1) + jumpFloor(target - 2);
        }
    }

 代码详解：

题目分析，假设 f[i] 表示在第i个台阶上可能的方法数。逆向思维。如果我从第n个台阶进行下台阶，下一步有2中可能，一种走到第 n-1 个台阶，一种是走到第 n-2个 台阶。

所以f[n] = f[n-1] + f[n-2]. 那么初始条件了，f[0] = f[1] = 1。 所以就变成了：f[n] = f[n-1] + f[n-2], 初始值f[0]=1, f[1]=1，目标求f[n] 看到公式很亲切，代码秒秒钟写完。 

此代码优点，代码简单好写，缺点：慢，会超时 时间复杂度：O(2^n) 空间复杂度：递归栈的空间。

方法二：记忆化搜索 拿求f[5] 举例

通过图会发现，上述方法中，存在很多重复计算，因为为了改进，就把计算过的保存下来。 那么用什么保存呢？一般会想到map， 但是此处不用牛刀，此处用数组就好了。

public class Solution {

    int f[40]{0};

    public int jumpFloor(int number) {
        if (number <= 1) {
            return 1;
        }
        if (f[number] > 0) {
            return f[number];
        }
        return f[number] = (jumpFloor(number - 1) + jumpFloor(number - 2));
    }
}

二、动态规划

虽然方法二可以解决此题了，但是如果想让空间继续优化，那就用动态规划，优化掉递归栈空间。 方法二是从上往下递归的然后再从下往上回溯的，最后回溯的时候来合并子树从而求得答案。 那么动态规划不同的是，不用递归的过程，直接从子树求得答案。过程是从下往上。

示例代码：

public class Solution {
    int dp[40]{0};
    public int jumpFloor(int number) {
        dp[0] = 1, dp[1] =1;
        for (int i = 2; i <= number; i ++) {
            dp[i] = dp[i-1]+dp[i-2];
        }
        return dp[number];
    }
}

时间复杂度：O(n)  空间复杂度：O(n) ；继续优化，发现计算 f[5] 的时候只用到了 f[4] 和 f[3] , 没有用到 f[2]...f[0], 所以保存 f[2]..f[0] 是浪费了空间。 只需要用3个变量即可。

 示例代码：

public class Solution {
    public int jumpFloor(int number) {
        // a表示f(n-2)的值，b表示f(n-1)的值，c表示f(n)的值
        int a = 1 , b = 1 , c = 1;
        for (int i = 2; i <= number; i ++) {
            c = a+b; 
            a = b; 
            b = c;
        }
        return c;
    }
}

 时间复杂度：O（n） 空间复杂度：O（1） 完美！