剑指offer青蛙跳台阶问题（普通跳和变态跳）

今天脑子里全是这个青蛙（呱呱呱）。有个普通的青蛙，还有一个变态的青蛙。我们来看一下吧。

普通青蛙

问题描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

分析

基本思路是菲波那切数列

解决方法

斐波那契数列递归实现

1斐波那契数列递归实现

如果n=1，只有一种跳法，那就是1
如果n=2，那么有两种跳法，2，[1,1]
如果n=3，那么有三种跳法，[1,1,1],,[1,2],[2,1]
如果n=4，那么有五种跳法，[1,1,1,1],[1,1,2],[1,2,1],[2,1,1],[2,2]
如果n=5，那么有八种跳法，[1,1,1,1,1],[1,1,1,2],[1,1,2,1],[1,2,1,1],[2,1,1,1],[2,2,1],[2,1,2],[1,2,2]

结果为1，2，3，5，8 。 这不就是斐波那契数列嘛

public class Solution {
public  int numWays(int n) {
        if (n <= 1)
            return 1;
        if (n < 3)
            return n;
        return f(n - 1) + f(n - 2);
    }
}

但递归由于重复计算，导致效率很差，会超时。所以我们可以采用动态规划的方法来解决。

动态规划实现

• 2.动态规划来实现

问题：跳上n级台阶的方法数
状态：F[i]:跳上i级台阶的方法数
初态：F[0]=1 F[1]=1 f[2]=2
转移方程：F[i]=f[i-1]+f[i-2]
返回F[n]：青蛙跳上n级台阶的方法数

public class Solution {
    public int numWays(int n) {
       if(n<=1)
       {
           return 1;
       }
       int[] arr=new int[n+1];
       arr[0]=1;
       arr[1]=1;
       arr[2]=2;
       for(int i=3;i<=n;i++)
       {
           arr[i]=arr[i-1]+arr[i-2];
       }
       return arr[n];
    }
}

动态规划优化

• 3.动态规划的优化

其实从状态转移方程我们也可以很清楚的看出来，F[n]只跟前两项即F[n-1], F[n-2]有关，既然如此那么我们就不需要申请那么多空间，直接用两个变量来表示前两项就可以了。

public class Solution {
    public int numWays(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
         if(n==2)
         {
             return 2;
         }
        // 两个变量表示前两项
        int f1 = 1, f2 = 2;
        int fn=0;
        for (int i = 3; i <= n; i++) {
             fn = f1 + f2;
            // 更新变量，以便继续求解
            f1 = f2;
            f2 = fn;
        }
        return fn;
    }
}

变态青蛙

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

分析

这只青蛙厉害了，他不管你有多少级台阶都可以直接一次跳上去。
如果n=1，只有一种跳法，那就是1
如果n=2，那么有两种跳法，2，[1,1]
如果n=3，那么有四种跳法，[1,1,1],[1,2],[2,1] [3]
如果n=4，那么有八种跳法，[1,1,1,1],[1,1,2],[1,2,1],[2,1,1],[2,2] [1,3] [3,1] [4]
可以得出
F(i)=F(i-1)+F(i-2)+…F(0)
F(i-1)=F(i-2)+F(i-3)+…F(0)
所以F(i)=F(i-1)+F(i-1)=2*F(i-1)

解决方案

暴力解法

• 1.暴力解法

因为F(1) = 1
所以F(i) = pow(2, n - 1)
代码如下

public class Solution {
    public int JumpFloorII(int n) {
    return n <= 0 ? 0 : 1 << (n - 1);
        //return (int)Math.pow(2,n-1);
    }
}

递归实现

• 2.递归写法

public class Solution {
    public int JumpFloorII(int n) {
   
            if (n <= 1) {
                return 1;
            } else {
                return 2 * JumpFloorII(n - 1);
            }
        }
}

动态规划实现

• 3.动态规划来解决
  问题：跳上n级台阶的方法数
  状态F[i]:跳上i级台阶的方法数
  初态： F[1]=1
  转移方程：F(i)=2*F(i-1)
  返回F[n]：青蛙跳上n级台阶的方法数

public class Solution {
    public int JumpFloorII(int n) {
   
            if (n < 2) {
                return 1;
            } 
        int[] arr=new int[n+1];
        arr[1]=1;      
        for(int i=2;i<=n;i++)
        {
            arr[i]=2*arr[i-1];
        }
        return arr[n];       
      }
}

动态规划优化

• 4.动态递归的优化

这个也是可以优化的，原因和上面类似。F[n]只跟前一项即F[n-1], 有关，既然如此那么我们就不需要申请那么多空间，直接用一个变量来表示前一项就可以啦。

public class Solution {
    public int JumpFloorII(int n) {
   
            if (n < 2) {
                return 1;
            }    
        int f1=1;
        int fn=0;
        for(int i=2;i<=n;i++)
        {
            fn=2*f1;
            f1=fn;
        }
        return fn;       
      }
}

好了，终于结束了,希望对大家有帮助。