Program for Fibonacci numbers

本篇文章翻譯自 http://www.geeksforgeeks.org/program-for-nth-fibonacci-number/

準備工作

首先先看一下Fibonacci numbers的定義

$$F_n = \begin{cases} 0 & \quad \text{if } n = 0\\ 1 & \quad \text{if } n = 1\\ F_{n-1} + F_{n-2} & \quad \text{otherwise}. \end{cases}$$
看完之後我們來我們來看實現 Fibonacci numbers的各種方法

Method1 遞迴

直接看Fibonacci numbers的定義寫出遞迴函式

//Fibonacci Series using Recursion
#include<stdio.h>
int fib(int n)
{
   if (n <= 1)
      return n;
   return fib(n-1) + fib(n-2);
}

Time Complexity: T(n) = T(n-1) + T(n-2) 呈指數成長

這個實作方式我們可以觀察到我們做了許多重複的工作(請看以下遞迴樹)，所以這是一個非常差的方法計算 $F_{n}$

                       fib(5)   
                     /             \     
               fib(4)                fib(3)   
             /      \                /     \
         fib(3)      fib(2)         fib(2)    fib(1)
        /     \        /    \       /    \  
  fib(2)   fib(1)  fib(1) fib(0) fib(1) fib(0)
  /    \
fib(1) fib(0)

Method2 Dynamic Programming(動態規劃)

使用Dynamic Programming我們可以試用array記住我們所算過的，可以避免掉Method1的重複計算。

//Fibonacci Series using Dynamic Programming
#include<stdio.h>

int fib(int n)
{
  /* Declare an array to store Fibonacci numbers. */
  int f[n+1];
  int i;

  /* 0th and 1st number of the series are 0 and 1*/
  f[0] = 0;
  f[1] = 1;

  for (i = 2; i <= n; i++)
  {
      /* Add the previous 2 numbers in the series
         and store it */
      f[i] = f[i-1] + f[i-2];
  }

  return f[n];
}

Time Complexity: O(n)
Extra Space: O(n)

Method 4 使用矩陣 $\left(\begin{smallmatrix}1 & 1 \\ 1 & 0\end{smallmatrix}\right)$

使用矩陣的表示方法我們可以發現以下以下這條式子:

$$\begin{bmatrix} 1 & 1 \\ 1 & 0 \end{bmatrix}^n = \begin{bmatrix} F_{n+1} & F_{n} \\ F_{n} & F_{n-1} \end{bmatrix}^n$$

#include <stdio.h>

/* Helper function that multiplies 2 matrices F and M of size 2*2, and
  puts the multiplication result back to F[][] */
void multiply(int F[2][2], int M[2][2]);

/* Helper function that calculates F[][] raise to the power n and puts the
  result in F[][]
  Note that this function is designed only for fib() and won't work as general
  power function */
void power(int F[2][2], int n);

int fib(int n)
{
  int F[2][2] = {{1,1},{1,0}};
  if (n == 0)
      return 0;
  power(F, n-1);

  return F[0][0];
}

void multiply(int F[2][2], int M[2][2])
{
  int x =  F[0][0]*M[0][0] + F[0][1]*M[1][0];
  int y =  F[0][0]*M[0][1] + F[0][1]*M[1][1];
  int z =  F[1][0]*M[0][0] + F[1][1]*M[1][0];
  int w =  F[1][0]*M[0][1] + F[1][1]*M[1][1];

  F[0][0] = x;
  F[0][1] = y;
  F[1][0] = z;
  F[1][1] = w;
}

void power(int F[2][2], int n)
{
  int i;
  int M[2][2] = {{1,1},{1,0}};

  // n - 1 times multiply the matrix to {{1,0},{0,1}}
  for (i = 2; i <= n; i++)
      multiply(F, M);
}

Time Complexity: O(n)
Extra Space: O(1)

Method5 (Method4 加強版本)

我們可以將Method 4算幾次方(power)這個函數優化(類似的方法可以參考這篇文章)

#include <stdio.h>

void multiply(int F[2][2], int M[2][2]);

void power(int F[2][2], int n);

/* function that returns nth Fibonacci number */
int fib(int n)
{
  int F[2][2] = {{1,1},{1,0}};
  if (n == 0)
    return 0;
  power(F, n-1);
  return F[0][0];
}

/* Optimized version of power() in method 4 */
void power(int F[2][2], int n)
{
  if( n == 0 || n == 1)
      return;
  int M[2][2] = {{1,1},{1,0}};

  power(F, n/2);
  multiply(F, F);

  if (n%2 != 0)
     multiply(F, M);
}

void multiply(int F[2][2], int M[2][2])
{
  int x =  F[0][0]*M[0][0] + F[0][1]*M[1][0];
  int y =  F[0][0]*M[0][1] + F[0][1]*M[1][1];
  int z =  F[1][0]*M[0][0] + F[1][1]*M[1][0];
  int w =  F[1][0]*M[0][1] + F[1][1]*M[1][1];

  F[0][0] = x;
  F[0][1] = y;
  F[1][0] = z;
  F[1][1] = w;
}

Time Complexity: O(Logn)
Extra Space: 如果我們考慮call stack的大小則為O(Logn)，否則為O(1)

Method6

以下是一個用很有趣的遞迴式:

$$F_n = \begin{cases} (2*F_{k-1} + F_{k})*F_{k} & \quad \text{If n is even then k = n/2:}\\ F_{k}^2 + F_{k-1}^2 & \quad \text{If n is odd then k = (n + 1)/2} \end{cases}$$
如果有興趣可以看以下的證明:
1. Wiki
2. Cassini’s Identity

// Returns n'th fuibonacci number using table f[]
int fib(int n)
{
    // Base cases
    if (n == 0)
        return 0;
    if (n == 1 || n == 2)
        return (f[n] = 1);

    // If fib(n) is already computed
    if (f[n])
        return f[n];

    int k = (n & 1)? (n+1)/2 : n/2;

    // Applyting above formula [Note value n&1 is 1
    // if n is odd, else 0.
    f[n] = (n & 1)? (fib(k)*fib(k) + fib(k-1)*fib(k-1))
           : (2*fib(k-1) + fib(k))*fib(k);

    return f[n];
}

Time Complexity: O(Logn)