剑指Offer——跳台阶

题目描述

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

思路分析

    这个问题可以先从简单开始考虑，台阶只有1阶，只有1种跳法，台阶有2阶，有2种跳法：一种两次跳一级；另一种一次跳两级。然后考虑一般情况，当有n级台阶时，将f(n)作为总跳法，第1次跳的时候，可以有两种方法：一是跳一级，此时跳法数目等于后面剩下的n-1级台阶的跳法，即f(n-1);二是跳两级，此时跳法数目等于后面剩下的n-2级台阶的跳法。所以，n级台阶的跳法总数：f(n)=f(n-1)+f(n-2)。从这里可以看出，本题是斐波那契数列的一种变形。

   但本题还有一种思路，就是将跳1级与跳2级看成排列组合问题，假设x为跳1级台阶的次数，y为跳2级台阶的次数，于是可知x+2y=n，即x=n-2y,这里可以看作对x与y的排列组合问题，即C(x+y,y)=C(n-y,y)。其中0<=y<=n/2。

代码实现

斐波那契数列实现

1、递归实现

    相信很多人第一次接触到斐波那契数列的时候，就是使用递归实现，该实现简单直观，但该算法效率不高，因为递归会反复计算相同的子问题，随着n的增大，计算量也急剧增大，时间复杂度为T(n) = O(1.618 ^ n)。代码如下：

 public int recurFib(int n) {
        if (n <= 0) {
            return 0;
        }
        if (n == 1 || n == 2) {
            return n;
        }
        return recurFib(n - 1) + recurFib(n - 2);
    }

2、递推实现

    使用递归实现的算法之所以效率太低，是因为重复计算太多，所以我们可以将中间结果保存，当再次计算的时候先查找一下。但有一种更简单的方法，就是从下向上计算，递归是从上到下计算，上面会依赖下面的值，因此会导致重复计算。我们使用从下往上计算，没有值依赖，算法复杂度就降为O(n)。首先根据f(1)和f(2)算出f(3),f(2)和f(3)算出f(4)，以此类推即可算出f(n)，实现代码如下:

  public int recursiveFib(int n) {
        if (n <= 0) {
            return 0;
        }
        if (n == 1 || n == 2) {
            return n;
        }
        int fibN = 0;
        int fibNMinusOne = 2;
        int fibNMinusTwo = 1;
        for (int i = 3; i <= n; i++) {
            fibN = fibNMinusOne + fibNMinusTwo;

            fibNMinusTwo = fibNMinusOne;
            fibNMinusOne = fibN;
        }
        return fibN;
    }

3、矩阵法实现

    还有一种矩阵法实现，算法效率最高，时间复杂度为O(logn)，该算法是根据下面的公式：

    上面的公式可以数学归纳法证明，感兴趣的可以自己搜索一下相关资料，有了上面的公式，就将求解f(n),转换成求二阶矩阵的n次方，然后取结果的第1行第2列即可。如果仅仅是矩阵的乘法，时间复杂度依旧为O(n)，但可以使用快速幂的方法求解一个数的乘法。乘方的性质如下：

     结合上面两个公式代码如下：

public class Solution {

    public int fib(int n) {
        if (n <= 0) {
            return 0;
        }
        if (n <= 2) {
            return n;
        }
        int[][] unitMatrix = {{1, 1}, {1, 0}};
        int[][] result = matrixPow(unitMatrix, n);
        return result[0][0];
    }

    public int[][] matrixPow(int[][] mat, int n) {
        if (n == 1) {
            return mat;
        } else {
            // n是偶数
            if ((n & 1) == 0) {
                int[][] temp = matrixPow(mat, n >> 1);
                return matrixMultiply(temp, temp);
            } else {
                // n是奇数
                int[][] temp = matrixPow(mat, (n - 1) >> 1);
                return matrixMultiply(matrixMultiply(temp, temp), mat);
            }
        }
    }

    /**
     * 矩阵相乘
     *
     * @param m
     * @param n
     * @return 结果矩阵，m*n
     */
    public int[][] matrixMultiply(int[][] m, int[][] n) {
        int rows = m.length;
        int cols = n[0].length;
        int[][] r = new int[rows][cols];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                r[i][j] = 0;
                for (int k = 0; k < m[i].length; k++) {
                    r[i][j] += m[i][k] * n[k][j];
                }
            }
        }
        return r;
    }

    public static void main(String args[]) {
        Solution s = new Solution();
        int result = s.fib(3);
        System.out.println(result);
    }
}

排列组合实现

    排列组合是将跳1级数目和跳2级数目看出一个组合，其中x为跳1级数目，y为跳2级数目，且x+2y=n，问题转换成从(x+y)个总跳数中选出y个跳2级的的组合，即C(x+y,y)=C(n-y,y)。实现代码如下：

public class Solution {

    public BigDecimal jiecheng(int number) {
        BigDecimal result = new BigDecimal(1);
        BigDecimal temp;
        for (int i = number; i > 0; i--) {
            temp = new BigDecimal(i);
            result = result.multiply(temp);
        }
        return result;
    }

    public int fib(int target) {
        if (target <= 0) {
            return 0;
        }
        BigDecimal result = new BigDecimal(0);
        // the result is C(n-y,y)
        for (int i = 0; i <= target / 2; i++) {
            result = result.add(jiecheng(target - i).divide(jiecheng(target - 2 * i).multiply(jiecheng(i))));
        }
        return result.toBigInteger().intValue();
    }

    public static void main(String args[]) {
        Solution s = new Solution();
        int result = s.fib(29);
        System.out.println(result);
    }

}