【算法】跳台阶

一、题目

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

二、解题思路

n级台阶的跳法有两种情况：

• 最后一跳跳了一级
• 最后一跳跳了两级

所以，n级台阶的跳法就相当于n-1级再跳一次一级台阶加上n-2级再跳一次二级台阶的跳法之和，由此可得出以下递推公式：

$f(n)=\{\begin{array}{ll}1,& n=1\\ 2,& n=2\\ f(n-1)+f(n-2),& n>2\end{array}$

分析到这里不难发现本题的本质与斐波那契数列问题相似。因此解题的方法也基本相同。

三、解题方法

代码实现使用 Python 2.7.3。

（一）递归

我们用递归算法就能够轻易实现以上式子，时间复杂度为$O(n^2)$。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloor(self, number):
        if number == 1:
            return 1
        elif number == 2:
            return 2
        else:
            return self.jumpFloor(n-1) + self.jumpFloor(n-2)

虽然用递归算法来实现是很自然又很简单的想法，但是其时间复杂度太高，其时间复杂度高的原因是，重复计算了很多不必要的数值。我们用计算$f(5)$来说明问题：

可以看到，在计算$f(5)$时，$f(3)$重复计算了两遍。

（二）遍历

由于递归算法产生了很多不必要的重复计算，导致时间复杂度很高。为了降低时间复杂度，我们首先的想法就是避免重复计算。

我们考虑对于任意一个$N$，我们从第一项开始计算，并将所有的中间结果保存下来，这样在计算$f(n)$时，只需要通过查表直接获取$f(n-1)$和$f(n-2)$的值计算即可，时间复杂度减少为$O(n)$。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloor(self, number):
        if number == 1:
            return 1
        elif number == 2:
            return 2
        else:
            array = [1, 2]
            for i in range(2, number):
                array.append(array[i-1]+array[i-2])
            return array[-1]

（三）矩阵乘法

实际上，遍历的方法还不是最优的，本题最优的解决方法的时间复杂度只需要$O(\log n)$。

$f(n)=f(n-1)+f(n-2)$是一个二阶递推数列，一定可以用矩阵乘法的形式表示，即状态矩阵为$2\times 2$的矩阵：
$$\left[\begin{array}{cc}f(n)& f(n-1)\end{array}\right]=\left[\begin{array}{cc}f(n-1)& f(n-2)\end{array}\right]\left[\begin{array}{cc}a& b\\ c& d\end{array}\right]$$可以解得$a=b=c=1,d=0$。再通过归纳法可得：

$$\begin{array}{rl}\left[\begin{array}{cc}f(n)& f(n-1)\end{array}\right]& =\left[\begin{array}{cc}f(n-1)& f(n-2)\end{array}\right]\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]\\ & =\left[\begin{array}{cc}f(n-2)& f(n-3)\end{array}\right]{\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]}^2\\ & =\cdots \cdots \\ & =\left[\begin{array}{cc}f(2)& f(1)\end{array}\right]{\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]}^{n-2}\\ & =\left[\begin{array}{cc}2& 1\end{array}\right]{\left[\begin{array}{cc}1& 1\\ 1& 0\end{array}\right]}^{n-2}\end{array}$$这样，求斐波那契数列第N项的问题就变成了如何用最快的方法求一个矩阵N次方的问题。

求整数N次方的问题与求矩阵N次方的问题同理。为了表示方便，用求一个整数N次方的例子来说明。快速求$10^{11}$的过程如下：

1. 11的二进制形式为1011
2. $10^{11}=10^{1\times 8}\times 10^{0\times 4}\times 10^{1\times 2}\times 10^{1\times 1}$

在这个过程中，我们先求出$10^1$，然后根据$10^1$求出$10^2$，再根据$10^2$求出$10^4$，…，最后求出$10^8$。因此，11的二进制数形式总共多少位，就使用了几次乘法

然后把应该累乘的值相乘即可，即$10^8$、$10^2$、$10^1$应该累乘，因为8、2、1对应到11的二进制数中，相应位上是1；而$10^4$不应该累乘，因为4对应到11的二进制数中，相应位上是0。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloor(self, number):
        if number == 1:
            return 1
        if number == 2:
            return 2
        else:
            array = [[1, 1], [1, 0]]
            res = [[1, 0], [0, 1]]
            
            times = number - 2
            while times:
                if (times&1) != 0:
                    a = res[0][0]*array[0][0] + res[0][1]*array[1][0]
                    b = res[0][0]*array[0][1] + res[0][1]*array[1][1]
                    c = res[1][0]*array[0][0] + res[1][1]*array[1][0]
                    d = res[1][0]*array[0][1] + res[1][1]*array[1][1]

                    res[0][0], res[0][1], res[1][0], res[1][1] = a, b, c, d
                
                a = array[0][0]*array[0][0] + array[0][1]*array[1][0]
                b = array[0][0]*array[0][1] + array[0][1]*array[1][1]
                c = array[1][0]*array[0][0] + array[1][1]*array[1][0]
                d = array[1][0]*array[0][1] + array[1][1]*array[1][1]

                array[0][0], array[0][1], array[1][0], array[1][1] = a, b, c, d

                times = times >> 1
                
            return 2 * res[0][0] + res[1][0]