Scribd
Upload
28 views

Intro: Fibonacci Numbers: Daniel Kane

This document introduces Fibonacci numbers and compares a naive recursive algorithm to an efficient iterative algorithm for computing Fibonacci numbers. The naive recursive algorithm runs in exponential time, taking over 56,000 years to compute F100. In contrast, the efficient iterative algorithm uses a list to store previously computed values, running in linear time and computing F100 instantly. The document emphasizes that choosing the right algorithm is crucial for performance.

Uploaded by

ADITYA
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
28 views

Intro: Fibonacci Numbers: Daniel Kane

This document introduces Fibonacci numbers and compares a naive recursive algorithm to an efficient iterative algorithm for computing Fibonacci numbers. The naive recursive algorithm runs in exponential time, taking over 56,000 years to compute F100. In contrast, the efficient iterative algorithm uses a list to store previously computed values, running in linear time and computing F100 instantly. The document emphasizes that choosing the right algorithm is crucial for performance.

Uploaded by

ADITYA
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 44

Intro:

Fibonacci Numbers
Daniel Kane
Department of Computer Science and Engineering
University of California, San Diego

Data Structures and Algorithms


Algorithmic Toolbox
Learning Objectives
Understand the definition of the
Fibonacci numbers.
Show that the naive algorithm for
computing them is slow.
Efficiently compute large Fibonacci
numbers.
Outline

1 Problem Overview

2 Naive Algorithm

3 Efficient Algorithm
Definition
⎧
⎨0, n = 0,
⎪
⎪
Fn = 1, n = 1,
⎪
⎩Fn−1 + Fn−2, n > 1 .
⎪
Definition
⎧
⎨0, n = 0,
⎪
⎪
Fn = 1, n = 1,
⎪
⎩Fn−1 + Fn−2, n > 1 .
⎪

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . .


Developed to Study Rabbit
Populations
Rapid Growth
Lemma
Fn ≥ 2n/2 for n ≥ 6 .
Rapid Growth
Lemma
Fn ≥ 2n/2 for n ≥ 6 .

Proof
By induction
Rapid Growth
Lemma
Fn ≥ 2n/2 for n ≥ 6 .

Proof
By induction
Base case: n = 6, 7 (by direct computation).
Rapid Growth
Lemma
Fn ≥ 2n/2 for n ≥ 6 .

Proof
By induction
Base case: n = 6, 7 (by direct computation).
Inductive step:

Fn = Fn−1 + Fn−2 ≥ 2(n−1)/2 + 2(n−2)/2 ≥


2 · 2(n−2)/2 = 2n/2.
Formula

Theorem

(︃(︃ √ )︃n (︃ √ )︃n )︃


1 1+ 5 1− 5
Fn = √ − .
5 2 2
Example

F20 = 6765
Example

F20 = 6765
F50 = 12586269025
Example

F20 = 6765
F50 = 12586269025
F100 = 354224848179261915075
Example

F20 = 6765
F50 = 12586269025
F100 = 354224848179261915075
F500 = 1394232245616978801397243828
7040728395007025658769730726
4108962948325571622863290691
557658876222521294125
Computing Fibonacci numbers

Compute Fn
Input: An integer n ≥ 0.
Output: Fn .
Outline

1 Problem Overview

2 Naive Algorithm

3 Efficient Algorithm
Algorithm

FibRecurs(n)
if n ≤ 1:
return n
Algorithm

FibRecurs(n)
if n ≤ 1:
return n
else:
return FibRecurs(n − 1) + FibRecurs(n − 2)
Running time

Let T (n) denote the number of lines of code


executed by FibRecurs(n).
If n ≤ 1

FibRecurs(n)
if n ≤ 1:
return n
else:
return FibRecurs(n − 1) + FibRecurs(n − 2)
If n ≤ 1

FibRecurs(n)
if n ≤ 1:
return n
else:
return FibRecurs(n − 1) + FibRecurs(n − 2)

T (n) = 2.
If n ≥ 2

FibRecurs(n)
if n ≤ 1:
return n
else:
return FibRecurs(n − 1) + FibRecurs(n − 2)
If n ≥ 2

FibRecurs(n)
if n ≤ 1:
return n
else:
return FibRecurs(n − 1) + FibRecurs(n − 2)

T (n) = 3
If n ≥ 2

FibRecurs(n)
if n ≤ 1:
return n
else:
return FibRecurs(n − 1) + FibRecurs(n − 2)

T (n) = 3 + T (n − 1) + T (n − 2).
Running Time

{︃
2 if n ≤ 1
T (n) =
T (n − 1) + T (n − 2) + 3 else.
Running Time

{︃
2 if n ≤ 1
T (n) =
T (n − 1) + T (n − 2) + 3 else.

Therefore T (n) ≥ Fn
Running Time

{︃
2 if n ≤ 1
T (n) =
T (n − 1) + T (n − 2) + 3 else.

Therefore T (n) ≥ Fn
T (100) ≈ 1.77 · 1021 (1.77 sextillion)
Running Time

{︃
2 if n ≤ 1
T (n) =
T (n − 1) + T (n − 2) + 3 else.

Therefore T (n) ≥ Fn
T (100) ≈ 1.77 · 1021 (1.77 sextillion)
Takes 56,000 years at 1GHz.
Why so slow?

Fn

Fn−1 Fn−2

Fn−2 Fn−3 Fn−3 Fn−4

Fn−3 Fn−4 Fn−4 Fn−5 Fn−4 Fn−5 Fn−5 Fn−6


...
Why so slow?

Fn

Fn−1 Fn−2

Fn−2 Fn−3 Fn−3 Fn−4

Fn−3 Fn−4 Fn−4 Fn−5 Fn−4 Fn−5 Fn−5 Fn−6


...
Why so slow?

Fn

Fn−1 Fn−2

Fn−2 Fn−3 Fn−3 Fn−4

Fn−3 Fn−4 Fn−4 Fn−5 Fn−4 Fn−5 Fn−5 Fn−6

Fn−4 Fn−5 Fn−5 Fn−6 Fn−5 Fn−6 Fn−6 Fn−7 Fn−5 Fn−6 Fn−6 Fn−7 Fn−6 Fn−7 Fn−7 Fn−8
..
.
Why so slow?

Fn

Fn−1 Fn−2

Fn−2 Fn−3 Fn−3 Fn−4

Fn−3 Fn−4 Fn−4 Fn−5 Fn−4 Fn−5 Fn−5 Fn−6

Fn−4 Fn−5 Fn−5 Fn−6 Fn−5 Fn−6 Fn−6 Fn−7 Fn−5 Fn−6 Fn−6 Fn−7 Fn−6 Fn−7 Fn−7 Fn−8
..
.
Outline

1 Problem Overview

2 Naive Algorithm

3 Efficient Algorithm
Another Algorithm

Imitate hand computation:


0, 1
Another Algorithm

Imitate hand computation:


0, 1, 1
0+1=1
Another Algorithm

Imitate hand computation:


0, 1, 1, 2
0+1=1
1+1=2
Another Algorithm

Imitate hand computation:


0, 1, 1, 2, 3
0+1=1
1+1=2
1+2=3
Another Algorithm

Imitate hand computation:


0, 1, 1, 2, 3, 5
0+1=1
1+1=2
1+2=3
2+3=5
Another Algorithm

Imitate hand computation:


0, 1, 1, 2, 3, 5, 8
0+1=1
1+1=2
1+2=3
2+3=5
3+5=8
New Algorithm
FibList(n)
create an array F [0 . . . n]
F [0] ← 0
F [1] ← 1
for i from 2 to n:
F [i] ← F [i − 1] + F [i − 2]
return F [n]
New Algorithm
FibList(n)
create an array F [0 . . . n]
F [0] ← 0
F [1] ← 1
for i from 2 to n:
F [i] ← F [i − 1] + F [i − 2]
return F [n]

T (n) = 2n + 2. So T (100) = 202.


Easy to compute.
Summary
Introduced Fibonacci numbers.
Naive algorithm takes ridiculously long
time on small examples.
Improved algorithm incredibly fast.
Summary
Introduced Fibonacci numbers.
Naive algorithm takes ridiculously long
time on small examples.
Improved algorithm incredibly fast.

Moral: The right algorithm makes


all the difference.

You might also like