356，青蛙跳台阶相关问题

想了解更多数据结构以及算法题，可以关注微信公众号“数据结构和算法”，每天一题为你精彩解答。也可以扫描下面的二维码关注

问题一：
一只青蛙一次可以跳上一级台阶，也可以跳上二级台阶，求该青蛙跳上一个n级的台阶总共需要多少种跳法。

我们来分析一下：

当n等于1的时候，只需要跳一次即可，只有一种跳法，记f(1)=1

当n等于2的时候，可以先跳一级再跳一级，或者直接跳二级，共有2种跳法，记f(2)=2

当n等于3的时候，他可以从一级台阶上跳两步上来，也可以从二级台阶上跳一步上来，所以总共有f(3)=f(2)+f(1)；

同理当等于n的时候，总共有f(n)=f(n-1)+f(n-2)(这里n>2)种跳法。

所以大家一看就知道这就是个斐波那契数列，只不过有一点不同的是斐波那契数列一般是以1,1,2,3,5,8,13……开始的，而我们这是以1,2,3,5,8,13……开始的，少了最前面的一个1。最代码很简单

	public static int f(int n) {
    if (n < 3)
          return n;
	    return f(n - 1) + f(n - 2);
	}

我们以计算f(6)为例画个图看一下计算的过程

我们看到递归会重复计算已经计算过的值，效率明显不是很高，我们还可以把计算过的值储存起来，防止重复计算，我们来看下代码

 	private static int f2(int n, HashMap<Integer, Integer> map) {
 	    if (n < 3) return n;
 	    if (map.containsKey(n))
  	       return map.get(n);
  	   int first = f2(n - 1, map);
  	   int second = f2(n - 2, map);
  	   int sum = first + second;
 	    map.put(n, sum);
  	   return sum;
	}

我们还可以把递归改为非递归的形式，看下代码

 	private static int f3(int n) {
 	    if (n < 3)
 	        return n;
 	    int first = 1, second = 2, sum = 0;
  	    while (n-- > 2) {
  	        sum = first + second;
  	        first = second;
 	        second = sum;
      }
	    return sum;
	}

上面3种方式都可以实现青蛙跳台阶问题，那么哪种效率更高呢，我们来找个比较大的数据测试一下

 	public static void main(String[] args) {
  	   int step = 45;
       long time = System.nanoTime();
  	   System.out.println(f(step));
       System.out.println("代码优化前时间：" + (System.nanoTime() - time));
       time = System.nanoTime();
       System.out.println(f2(step, new HashMap<Integer, Integer>()));
  	   System.out.println("代码优化后时间：" + (System.nanoTime() - time));
       time = System.nanoTime();
 	   System.out.println(f3(step));
 	   System.out.println("代码非递归时间：" + (System.nanoTime() - time));
	}

来看一下运行的时间

	1836311903
	代码优化前时间：2221741900
	1836311903
	代码优化后时间：108000
	1836311903
	代码非递归时间：17600

我们看到递归优化之前运行时间是非常长的，优化之后时间大幅下降，但对于非递归来说又稍逊色了一些。

问题二：
一只青蛙一次可以跳上一级台阶，也可以跳上二级台阶……，也可以跳n级，求该青蛙跳上一个n级的台阶总共需要多少种跳法。

我们来分析一下
一只青蛙要想跳到n级台阶，可以从一级，二级……，也就是说可以从任何一级跳到n级，

所以递推公式我们很容易就能想到
f(n)=f(n-1)+f(n-2)+……+f(2)+f(1)+f(0)；最后这个f(0)是可以去掉的，因为0级就相当于没跳，所以f(0)=0;
然后我们把f(0)去掉在转换一下：
f(n-1)=f(n-2)+f(n-3)+……+f(2)+f(1)；
所以f(n)=f(n-1)+f(n-1)=2*f(n-1)；他是一个等比数列，且f(1)=1;
我们我们可以得出f(n)=2^(n-1)；代码如下

	private static int f4(int n) {
	    if (n == 1)
 	       return 1;
 	   return f4(n - 1) * 2;
	}

或者还可以改为非递归的

	private static int f5(int n) {
 	   if (n == 1)
  	      return 1;
 	   return 1 << (n - 1);
	}

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

这道题我们要分开讨论：
1，如果n<=m；因为只能往上跳不能往下跳，所以大于n的都不可以跳，如果跳了就直接超过了，只能跳小于等于n的数字，那么这个问题就直接退到问题2了。

2，如果n>m；我们要想跳到n级台阶，我们可以从n-1级跳一步上来，或者从n-2级跳两步上来……，或者从n-m级跳m步上来，所以我们可以找出递归公式

f(n) = f(n-1) + f(n-2) + f(n-3) + … + f(n-m)；
进一步可以推出：
f(n-1) = f(n-2) + f(n-3) + … + f(n-m) + f(n-m-1)；
化简结果为：
f(n) = 2f(n-1) - f(n-m-1)；(n>m)
所以代码我们要分为两部分，一部分是n>m，另一部分是n<=m，我们来看下代码

	public static int f6(int n, int m) {
	    if (n <= 1)
 	       return 1;
  	  //总台阶大于跳的最高级台阶
	    if (n > m)
	        return 2 * f6(n - 1, m) - f6(n - 1 - m, m);
  	  //回退到上面的问题二了
 	   return 2 * f6(n - 1, n);
	}

斐波那契数列又称黄金分割数列，他有很多的特性，比如兔子的繁殖，他的通项公式如下