青蛙变态跳台阶问题

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

分析：因为n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级

跳1级，剩下n-1级，则剩下跳法是f(n-1)
跳2级，剩下n-2级，则剩下跳法是f(n-2)

所以f(n) = f(n-1) + f(n-2) + ... + f(1)
因为f(n-1) = f(n-2) + f(n-3 )+ ... + f(1)

所以f(n) = 2 * f(n-1)。

根据f(1) = 1，f(n) = 2 * f(n-1)，可以得出f(n) = 2^(n-1)。

或者可以这么分析：每个台阶都有跳与不跳两种情况（除了最后一个台阶），最后一个台阶必须跳。所以共用2^(n-1)种情况。

第一种方法使用递归求解的代码如下：

public class Solution {

    public static void main(String[] args) {
        Long begintime = System.nanoTime();
        int result = JumpFloorII(10);
        Long endtime = System.nanoTime();
        System.out.println("result="+result+"；用时："+(endtime-begintime)+"ns");
    }

    public static int JumpFloorII(int target) {
        if (target < 1) {
            return 0;
        } else if (target == 1) {
            return 1;
        } else {
            return 2 * JumpFloorII(target - 1);
        }
    }

}

程序运算结果：

该算法的时间复杂度是O(n)，和求阶乘的时间复杂度类似。这种方法属于自顶向下的算法。

也可以使用自底向上的方法解决这个问题。代码如下：

第二种方法使用循环求解的代码如下：

public class Solution {

    public static void main(String[] args) {
        Long begintime = System.nanoTime();
        int result = JumpFloorII(10);
        Long endtime = System.nanoTime();
        System.out.println("result="+result+"；用时："+(endtime-begintime)+"ns");
    }

    public static int JumpFloorII(int target) {
        if(target < 1){
            return 0;
        }
        if(target == 1){
            return 1;
        }
        int a = 1;
        int temp = 1;
        for(int i = 2; i <= target; i++){
            temp = 2 * a;
            a = temp;
        }
        return temp;
    }

}

程序执行结果：

这种算法的时间复杂度是O(n)。 

也可以使用动态规划解决这个问题，这时的[状态转移方程]就变成了F(n) = 2*F(n-1)。 

第三种方法使用动态规划求解的代码如下：

public class Solution {

    public static void main(String[] args) {
        Long begintime = System.nanoTime();
        int result = JumpFloorII(10);
        Long endtime = System.nanoTime();
        System.out.println("result="+result+"；用时："+(endtime-begintime)+"ns");
    }

    public static int JumpFloorII(int target) {
        //第n次走的台阶个数是第n-1次走的台阶个数的2倍
        //所以状态转移方程为 dp[i] = 2*dp[i-1];
        int[] dp = new int[target+1];
        dp[0] = dp[1] = 1;
        for (int i=2; i<=target; ++i) {
            dp[i] = 2*dp[i-1];
        }
        return dp[target];
    }

}

程序执行结果：

使用动态规划循环执行了n-1次，所以这里动态规划算法的时间复杂度是O(n)。

或者可以直接从公式入手，根据推导出的公式f(n) = 2^(n-1)，那么JumpFloorII方法就可以变成如下。

第四种方法使用公式求解的代码如下：

public int JumpFloorII(int target) {
        if (target < 1) {
            return 0;
        }else {
            return (int) Math.pow(2, target-1);
        }
}

为了更加提高效率，可以把乘法变为左移运算，因为在计算机中移位运算的操作效率要优于乘除法。移位运算可以把算法的时间复杂度降到常数级别，效率还是很高的。但是要注意对于移位运算，答案不要溢出，虽然不用处理但是在面试时要考虑溢出的问题并说明。 

第五种方法使用移位运算求解的代码如下： 

public int JumpFloorII(int target) {
    if (target < 1) {
            return 0;
        }else {
        return  1<<--target;
        }
}

或者这样：

public static int JumpFloorII(int target) {
        if(target < 1) return 0;
        if(target == 1) return 1;
        return 2<<(target-2);
}

这个也要考虑内存溢出的问题。上面两个就是移位运算的解法，移位运算解法的时间复杂度是O(1)。

参考:（1）https://blog.csdn.net/qq_27703417/article/details/70983672