9 Approaches | Fibonacci | The Most Complete Solutions | All In One

By Long Luo

The Fibonacci numbers are the numbers in the following integer sequence:

1,1,2,3,5,8,13,21,34,55,89,144,233,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ……

Fibonacci Sequences

We can see the fibonacci series seqences in the natrual world like the sunflower, the nautilus and the galaxy.

Fibonacci Natrual

In mathematical terms, the sequence F(n)F(n) of Fibonacci numbers is defined by the recurrence relation

F(n)=F(n1)+F(n2)F(n)=F(n-1)+F(n-2)

with seed values F(0)=0F(0) = 0 and F(1)=1F(1) = 1.

The Fibonacci sequence is often used in introductory computer science courses to explain recurrence relations, dynamic programming, and proofs by induction. Because the Fibonacci sequence is central to several core computer science concepts, the following programming problem has become fairly popular in software engineering interviews.

1
Given an input n, return the nth number in the Fibonacci sequence.

Below I’ve listed 9 solutions to this problem, ranked from least efficient to most. These different solutions illustrate different programming and algorithmic techniques that can be used to solve other problems. You’ll notice that many of these solutions build from previous solutions.

Solution 1 Lookup Table - 32 bit signed integers only

If we don’t need to solve very large values and are time-sensitive, we can calculate all values in advance.

This function will work strictly in the case that we’re dealing with 32 bit signed integers (which could be a constraint in languages like Java, C/C++, etc.)

The Fibonacci sequence grows very quickly. So fast, that only the first 47 Fibonacci numbers fit within the range of a 32 bit signed integer. This method requires only a quick list lookup to find the nth Fibonacci number, so it runs in constant time. Since the list is of fixed length, this method runs in constant space as well.

1
2
3
4
5
6
7
8
9
10
11
12
class Solution {
int[] fib_nums = {
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,
6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040,
1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986,
102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903
};

public int fib(int n) {
return fib_nums[n];
}
};

Analysis

  • Time Complexity: O(1)O(1)
  • Space Complexity: O(1)O(1)

Solution 2 Recursion

A simple method that is a direct recursive implementation mathematical recurrence relation is given above.

1
2
3
4
5
6
7
8
//Fibonacci Series using Recursion
public static int fib(int n) {
if (n <= 1) {
return n;
}

return fib(n - 1) + fib(n - 2);
}

Analysis

Time Complexity: O(ϕn)O(\phi^n), where ϕ\phi is the golden ratio (ϕ1.618...\phi \simeq 1.618...).

If we count the number of calls that this algorithm makes for any n, we will find its runtime complexity.

Let T(n)T(n) refer to the number of calls to fib1 that are required to evaluate fib1(n).

When fib1(0) or fib1(1) is called, fib1 doesn’t make any additional recursive calls, so T(0)T(0) and T(1)T(1) must equal 1.

For any other n, when fib1(n) is called, fib1(n - 1) and fib1(n - 2) are also called.

So

T(n)=1+T(n1)+T(n2)T(n) = 1 + T(n - 1) + T(n - 2)

Using more advanced mathematical techniques, like generating functions, one can solve the recurrence TT, and find that TT scales as O(ϕ)O(\phi).

If the original recursion tree were to be implemented then this would have been the tree but now for n times the recursion function is called.

Original tree for recursion:

1
2
3
4
5
6
7
8
9
                          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)

Optimized tree for recursion for code above:

1
2
3
4
5
fib(5) 
fib(4)
fib(3)
fib(2)
fib(1)

Space Complexity: O(n)O(n) if we consider the function call stack size, otherwise O(1)O(1).

Solution 3 Dynamic Programming

We can avoid the repeated work done in [method 2](#Solution 2 Recursion) by storing the Fibonacci numbers calculated so far.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Dynamic Programming
public int fib(int n) {
/* Declare an array to store Fibonacci numbers. */
int f[] = new int[n + 1]; // 1 extra to handle case, n = 0
int i;

/* 0th and 1st number of the series are 0 and 1*/
f[0] = 1;
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];
}

Analysis

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

Solution 4 DP using memoization(Top down approach)

We can avoid the repeated work done in [method 2](#Solution 2 Recursion) by storing the Fibonacci numbers calculated so far. We just need to store all the values in an array.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Initialize array of dp
public static int[] dp = new int[31];

public static int fib(int n) {
if (n <= 1) {
return n;
}

// Temporary variables to store values of fib(n-1) & fib(n-2)
int first, second;

if (dp[n - 1] != -1) {
first = dp[n - 1];
} else {
first = fib(n - 1);
}

if (dp[n - 2] != -1) {
second = dp[n - 2];
} else {
second = fib(n - 2);
}

// Memoization
return dp[n] = first + second;
}

Analysis

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

Solution 5 Iterative (Space Optimized Method 3)

We can optimize the space used in [method 3](#Solution 3 Dynamic Programming) by storing the previous two numbers only because that is all we need to get the next Fibonacci number in series.

This solution is one of the simplest and most efficient algorithms on this list. This function has a loop that runs through n iterations before returning, and each iteration does constant work, making the algorithm run in O(n)O(n) time. This function doesn’t use any extra data structures, and it isn’t recursive, so we can say that it uses O(1)O(1) space.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Fibonacci Series using Space Optimized Method
class Solution {
public int fib(int n) {
if (n < 2) {
return n;
}
int p = 0, q = 0, r = 1;
for (int i = 2; i <= n; ++i) {
p = q;
q = r;
r = p + q;
}
return r;
}
}

Analysis

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

Solution 6 Recurrence Matrix

This is the most mathematical solution, and it requires some basic understanding of matrix multiplication.

Consider the following matrix MM:

M=[1110]M = \begin{bmatrix} 1 & 1 \\ 1 & 0 \\ \end{bmatrix}

If fi1f_{i-1} and fi2f_{i-2} are the i1i-1th and the i2i-2th Fibonacci numbers, the following matrix product can give us the ith Fibonacci number fif_{i}:

M[fi2fi1]=[fi1fi1+fi2]=[fi1fi]M * \begin{bmatrix} f_{i - 2} \\ f_{i - 1} \end{bmatrix} = \begin{bmatrix} f_{i - 1} \\ f_{i - 1} + f_{i - 2} \end{bmatrix} = \begin{bmatrix} f_{i - 1} \\ f_{i} \end{bmatrix}

Using this property of MM, one can find fnf_{n} by computing the product

Mn[f0f1]=Mn[01]M^n * \begin{bmatrix} f_0 \\ f_1 \end{bmatrix} = M^n * \begin{bmatrix} 0 \\ 1 \end{bmatrix}

and returning the first element of the vector.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Solution {
public static int fib(int n) {
int F[][] = new int[][]{{1, 1}, {1, 0}};
if (n == 0) {
return 0;
}
power(F, n - 1);
return F[0][0];
}

/* Helper function that multiplies 2 matrices F and M of size 2*2, and
puts the multiplication result back to F[][] */
public static void multiply(int F[][], int M[][]) {
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;
}

/* 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 */
public static void power(int F[][], int n) {
int i;
int M[][] = new int[][]{{1, 1}, {1, 0}};

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

Analysis

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

Solution 7 Fast Matrix Power(Optimized Method 6)

The [method 6](#Solution 6 Recurrence Matrix) can be optimized to work in O(\log n) time complexity. We can do recursive multiplication to get power(M, n) in the previous method (Similar to the optimization done in this post).

The key here is to compute MnM^n using the successive square method. Using this algorithm, MnM^n is computed in O(logn)O(logn) time(Note that for a fixed matrix size, the matrix muliplication algorithm takes a constant amount of time).

Then, MnM^n is multiplied by [01]\begin{bmatrix} 0 \\ 1 \end{bmatrix}, and the top elemen of the product is returned.

This algorithm uses O(logn)O(logn) to compute MnM^n, and constant space, as the intermediary matricies can be reclaimed by the garbage collecter.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Solution {
public int fib(int n) {
if (n < 2) {
return n;
}
int[][] q = {{1, 1}, {1, 0}};
int[][] res = pow(q, n - 1);
return res[0][0];
}

public int[][] pow(int[][] a, int n) {
int[][] ret = {{1, 0}, {0, 1}};
while (n > 0) {
if ((n & 1) == 1) {
ret = multiply(ret, a);
}
n >>= 1;
a = multiply(a, a);
}
return ret;
}

public int[][] multiply(int[][] a, int[][] b) {
int[][] c = new int[2][2];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
}
}
return c;
}
}

Analysis

  • Time Complexity: O(logn)O(\log n).
  • Space Complexity: O(logn)O(\log n) if we consider the function call stack size, otherwise O(1)O(1).

Solution 8 O(Log n) Time

Below is one more interesting recurrence formula that can be used to find nth Fibonacci number in O(Logn)O(Log_n) time.

If nn is even then k=n/2k = n/2:

F(n)=[2F(k1)+F(k)]F(k)F(n) = [2*F(k-1) + F(k)]*F(k)

If nn is odd then k=(n+1)/2k = (n + 1)/2

F(n)=F(k)F(k)+F(k1)F(k1)F(n) = F(k)*F(k) + F(k-1)*F(k-1)

How does this formula work?

The formula can be derived from above matrix equation.

An=(Fn+1,FnFn,Fn1)A^n=\begin{pmatrix} F_{n+1},&F_n \\ F_n,&F_{n-1} \end{pmatrix}

Taking determinant on both sides, we get:

(1)n=Fn+1Fn1Fn2(-1)^n = F_{n+1} * F_{n-1} - F_n^2

Moreover, since AnAm=An+mA^nA^m = A^{n+m} for any square matrix AA, the following identities can be derived (they are obtained form two different coefficients of the matrix product)

FmFn+Fm1Fn1=Fm+n1(8.1)F_mF_n + F_{m-1}F_{n-1} = F_{m+n-1} ------(8.1)

By putting n=n+1n=n+1 in equation (8.1),

FmFn+1+Fm1Fn=Fm+n(8.2)F_mF_{n+1} + F_{m-1}F_n = F_{m+n} ------(8.2)

Putting m=nm = n in equation(8.1).

F2n1=Fn2+Fn12F_{2n-1} = F_n^2 + F_{n-1}^2

Putting m=nm = n in equation(8.2)

By putting: Fn+1=Fn+Fn1F_{n+1} = F_n + F_{n-1}

F2n=(Fn1+Fn+1)Fn=(2Fn1+Fn)FnF_{2n} = (F_{n-1} + F_{n+1})Fn = (2F_{n-1} + F_n)F_n

To get the formula to be proved, we simply need to do the following

If nn is even, we can put k=n/2k = n/2
If nn is odd, we can put k=(n+1)/2k = (n+1)/2

Below is the implementation of above idea.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static int MAX = 1000;
public static int f[];

// Returns n'th fibonacci number using
// table f[]
public static int fib(int n) {
if (n == 0) {
return 0;
}

if (n == 1 || n == 2) {
return (f[n] = 1);
}

// If fib(n) is already computed
if (f[n] != 0) {
return f[n];
}

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

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

return f[n];
}

Analysis

  • Time Complexity: O(logn)O(\log n) as we divide the problem to half in every recursive call.
  • Space Complexity: O(logn)O(\log n)

Solution 9 Math Formula

We first look at the equation:

F(n)=F(n1)+F(n2)(9.1)F(n)=F(n-1)+F(n-2) ------(9.1)

To solve (9.1) for the Fibonacci numbers, we first look at the equation

xn+1=xn+xn1(9.2)x_{n+1} = x_n + x_{n-1} ------(9.2)

This equation is called a second-order, linear, homogeneous difference equation with constant coefficients, and its method of solution closely follows that of the analogous differential equation.

Our idea is to guess the general form of a solution, find two such solutions, and then multiply these solutions by unknown constants and add them. This results in a general solution to (9.2), and one can then solve by satisfying the specified initial values.

To begin, we guess the form of the solution as

xn=λn(9.3)x_n = λ^n ------(9.3)

where λλ is an unknown constant.

Substitution of this guess into the equation, results in:

λn+1=λn+λn1λ^{n+1} = λ^n + λ^{n-1}

or upon division by λn1λ^{n-1} and rearrangement of terms,

λ2λ1=0λ^2 - λ - 1 = 0

Use of the quadratic formula yields two roots, both of which are already familiar. We have:

λ1=1+52λ_1 = \frac{1+\sqrt{5}}{2}

λ2=152λ_2 = \frac{1-\sqrt{5}}{2}

We have thus found two independent solutions to (9.2) of the form (9.3), and we can now use these two solutions to find a solution to (9.1). Multiplying the solutions by constants and adding them, we obatin:

F(n)=c1λ1n+c2λ2nF(n)=c_1λ_1^n+c_2λ_2^n

which must satisfy the initial values F(0)=1F(0)=1F(1)=1F(1)=1.

Application of the values for F0F0 and F1F1 results in the system of equations given by

c1+c2=0c_1 + c_2 = 0

c1λ1c2λ2=1c_1λ_1 - c_2λ_2 = 1

we can solve for c1c_1 and c2c_2 to obtain:

c1=15c_1=\frac{1}{\sqrt{5}}c2=15c_2=-\frac{1}{\sqrt{5}}.

then derives the surprising formula:

F(n)=15[(1+52)n(152)n]F(n)=\frac{1}{\sqrt{5}}\left[ \left(\frac{1+\sqrt{5}}{2}\right)^{n} - \left(\frac{1-\sqrt{5}}{2}\right)^{n} \right]

known as Binet’s formula.

In this method we directly implement the formula for nth term in the fibonacci series.

1
2
3
4
5
6
7
class Solution {
public int fib(int n) {
double sqrt5 = Math.sqrt(5);
double fibN = Math.pow((1 + sqrt5) / 2, n) - Math.pow((1 - sqrt5) / 2, n);
return (int) Math.round(fibN / sqrt5);
}
}

Analysis

  • Time Complexity: O(logn)O(\log n), this is because calculating phinphi^n takes lognlogn time
  • Space Complexity: O(1)O(1).

All suggestions are welcome.
If you have any query or suggestion please comment below.
Please upvote👍 if you like💗 it. Thank you:-)

Explore More Leetcode Solutions. 😉😃💗