青蛙变态跳台阶问题

题目描述

一只青蛙一次可以跳上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

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值