[每日算法15分鐘] 生成斐波那契數列第N項

算法分析是我最喜歡的課程之一。一個精妙的算法，猶如一杯香濃的咖啡，讓人意猶未盡。
算法代碼，python。

今天分享的這個算法是生成斐波那契數列第N項。
斐波那契數列（Fibonacci sequence）
$F_0=0, F_1 = 1, F_2 = 1, ... ,F_n = F_{n-2}+F_{n-1}$

寫一個方法def fibonacci(n) 生成$F_n$項，輸入參數n表示序列號，返回值是$F_n$的值：

直觀樸素的算法：

def fibonacci(n):
    if n == 0: 
        return 0
    elif n == 1:
        return 1
    elif n > 1:
        return fibonacci(n-2) + fibonacci(n-1)

print(fibonacci(7))

使用這個遞歸算法，效率如何呢？
當n = 0時，該方法調用次數是1
當n = 1時，該方法調用次數是1
當n = 2時，該方法調用次數是3

當n = 3時，該方法調用次數是5

當n = 4時，該方法調用次數是9

以此類推，
當n = 5時，該方法調用次數是15
當n = 6時，該方法調用次數是25
隨着n的增長，該算法的複雜度呈指數級增長，這是很糟糕的情況，如果n值大一些，那就有可能超出編程語言的最大遞歸次數而無法獲得有效結果。

有沒有更高效的算法？
仔細觀察上圖，你會發現在計算過程中會出現許多重複調用，比如fibonacci(0)被重複調用了2次，fibonacci(1)被重複調用了3次。因此，我們可以把之前算過的結果存下來。

直觀的順序算法

def fibonacci(n):
    f_n_2 = 0
    f_n_1 = 1
    f_n = 0
    for i in range(n-1):
        f_n = f_n_2 + f_n_1
        f_n_2 = f_n_1
        f_n_1 = f_n
    return f_n

print(fibonacci(7))

以上這個算法記錄$f_{n-2}$和$f_{n-1}$的值，避免了重複運算，算法複雜度是線性的，效率較之前提升了不少。

那還有沒有更高效的算法？

遞歸平法算法

有的，可以利用矩陣的n次方來計算斐波那契數列。
$F_0 = 0， F_1=1, F_2 = 1, 則， \left\{ \begin{matrix} F_2, F_1 \\ F_1,F_0 \end{matrix} \right\} = \left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^1$

$假設,\left\{ \begin{matrix} F_{n-1}, F_{n-2} \\ F_{n-2}, F_{n-3} \\ \end{matrix} \right\} = \left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^{n-2}$

$\left\{ \begin{matrix} F_{n-1}, F_{n-2} \\ F_{n-2}, F_{n-3} \\ \end{matrix} \right\} \left\{ \begin{matrix} 1, 1\\ 1,0\\ \end{matrix} \right\} = \left\{ \begin{matrix} F_{n-1}+F_{n-2},F_{n-1} \\ F_{n-2}+F_{n-3},F_{n-2} \\ \end{matrix} \right\} = \left\{ \begin{matrix} F_n, F_{n-1}\\ F_{n-1}, F_{n-2} \end{matrix} \right\}$

$由此，\left\{ \begin{matrix} F_n, F_{n-1} \\ F_{n-1}, F_{n-2} \end{matrix} \right\}= \left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^{n-1}$

因此，我們可以通過計算 $\left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^{n-1}$來獲得$F_n$的值。

計算$\left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^n$則可以使用以下遞歸算法。

$\left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^n=\biggl\{^{\left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^{n/2}.\left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^{n/2} ...n是偶數} _{\left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^{(n-1)/2}.\left\{ \begin{matrix} 1, 1\\ 1,0 \end{matrix} \right\}^{(n-1)/2} ...n是奇數}$

def fibonacci(n):
    if n == 0:
        return 0
    if n == 1:
        return 1 
    else:
        f_matrix = fibonacci_matrix(n)
        return f_matrix[0][0]
        
def fibonacci_matrix(n): 
    if n < 2:
        return -1
    elif n == 2:
        f_n = 1
        f_n_1 = fibonacci_matrix(n-1)
        f_n_2 = fibonacci_matrix(n-2)
    elif n > 1 and n%2 == 0:
        f = fibonacci_matrix(n/2)
        f_n = f[0][0]* f[0][0] + f[0][1]*f[1][0]+f[0][0]* f[0][1] + f[0][1]*f[1][1]
        f_n_2 = f[0][0]* f[0][1] + f[0][1]*f[1][1]
        f_n_1 = f_n-f_n_2        
    else:
        f = fibonacci_matrix((n+1)/2)
        f_n = f[0][0]* f[0][0]+f[0][1]* f[1][0]
        f_n_1 = f[0][0]* f[0][1]+f[0][1]*f[1][1]
        f_n_2 = f_n - f_n_1
    return [[f_n,f_n_1],[f_n_1,f_n_2]] 

這個算法的複雜度時對數級的，比之前的算法又有改進。

我們可以來看一下，算法二和算法三的速度對比，分別是n=10000，n=50000，n=100000時的耗時，隨着n的增長算法三的優勢就顯而易見了。
算法二

1st run - n=10000 :
0:00:00.004448
2nd run - n=50000:
0:00:00.038660
3rd run - n=100000:
0:00:00.164054

算法三

Recursive Squaring
1st run - n=10000 :
0:00:00.000158
2nd run - n=50000:
0:00:00.001296
3rd run - n=100000:
0:00:00.005507

今天的斐波那契數列算法就講到這裏。