Question

Java (Please answer in a specific way and not just show the program)

Determine the largest values of n for which the corresponding Fibonacci Numbers can be computed within the given time.

n = _____ time required: less than 10 seconds

n = _____ time required: less than 30 seconds

n = _____ time required: less than 1 minute

n = _____ time required: less than 5 minutes

Estimate the value of n for the largest value of fib(n) that can be computed using recursion in one hour on your computer. Explain in detail how you estimated this value. Also describe any additional data you took to arrive at this value. Attach any additional work required.

n = ______ for time required = 1 hour (3600 seconds)

Repeat this problem for the largest value of n for which the corresponding Fibonacci number can be computed in one day (86,400 seconds).

n = ______ for time required = 1 day (86,400 seconds)

Repeat this problem for the largest value of n for which the corresponding Fibonacci number can be computed in one year.

n = ______ for time required = 1 year.

Repeat this problem for the largest value of n for which the corresponding Fibonacci number can be computed in one million years (106years).

n = ______ for time required = 1 million years.

Memoization

The time complexity is exponential so this simplistic recursive approach becomes intractable when we get into the fifties or so. We can greatly increase our time performance with “memoization” – that is, every time we compute a value we make a note (or memo) of it and check that “memo” list before computing.

Add memoization to your Fibonacci program. At what point does the computation time become more than one second?

Answer 1

If n = 0, then fib() should return 0. If n = 1, then it should return 1. For n > 1, it should return F_n-1 + F_n-2

Method 1 ( Use recursion )
A simple method that is a direct recursive implementation mathematical recurrence relation given above.

//Fibonacci Series using Recursion

#include<stdio.h>

using namespace std;   

int fib(int n) {

    if (n <= 1)

        return n;

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

}

int main ()

{

    int n = 9;

    cout << fib(n);

    getchar();

    return 0;

}

Time Complexity: T(n) = T(n-1) + T(n-2) which is exponential.
We can observe that this implementation does a lot of repeated work (see the following recursion tree). So this is a bad implementation for nth Fibonacci number.

Method 2 ( Use Dynamic Programming )
We can avoid the repeated work done in method 1 by storing the Fibonacci numbers calculated so far.

//Fibonacci Series using Dynamic Programming

#include<stdio.h>

int fib(int n)

{

  /* Declare an array to store Fibonacci numbers. */

  int f[n+2];   // 1 extra to handle case, n = 0

  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];

}

int main ()

{

  int n = 9;

  printf("%d", fib(n));

  getchar();

  return 0;

}

Method 3 ( Space Optimized Method 2 )
We can optimize the space used in method 2 by storing the previous two numbers only because that is all we need to get the next Fibonacci number in series.

// Fibonacci Series using Space Optimized Method

#include<stdio.h>

int fib(int n)

{

  int a = 0, b = 1, c, i;

  if( n == 0)

    return a;

  for (i = 2; i <= n; i++)

  {

     c = a + b;

     a = b;

     b = c;

  }

  return b;

}

int main ()

{

  int n = 9;

  printf("%d", fib(n));

  getchar();

  return 0;

}

After looking at time complexity for all solutions it was concluded that the recursive solution was getting significantly slower for each additional number in the sequence due to exponential time growth. There is, however, a smart way of improving this solution and that is using Memoization.

“Memoization is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.”

Let’s define our memoize function. It will receive a function as an argument and also return a function. We will also create an empty object that will actually store function calls for us.

function memoize(fn){
  const cache = {}
  return function(){
  }
}

The function that is returned in memoize needs to receive the same argument n as the ones we’d pass to fib. However if we were to write a reusable memoizer that can be applied to functions other that fib, we would want to allow it to receive any number of arguments like so:

function memoize(fn){
  const cache = {}
  return function(...args){
  }
}

From here we will need to look into our memory bank, our cache constant, and if it contains a key with this set of arguments, we will return the corresponding value.

function memoize(fn){
  const cache = {}
  return function(...args){
    if (cache[args]){
      return cache[args];
    }
  }
}

If the function has never been called with the current set of arguments we will have to pass them to the original “slow” function that is the fn passed to memoize as an argument and then save the result to cache. In order to pass an array of arguments we need to use apply() method.

function memoize(fn){
  const cache = {}
  return function(...args){
    if (cache[args]){
      return cache[args];
    }
    newCall = fn.apply(null, args);
    cache[args] = newCall;
    return newCall;
  }
}

To use memoize function for our Fibonacci problem we simply store memoize function call as a constant and pass arguments that would otherwise be passed to fib to this constant.

const fastFib = memoize(fib);

And, finally, we need to make sure that when fib performs recursive calls, it calls the new fast version of itself rather than the original self.

const fastFib = memoize(fib);

function fib(n) {
  if (n < 2) {
    return n;
  }
  return fastFib(n - 1) + fastFib(n - 2);
}

And that’s it! We have significantly improved the time that it will take the recursive solution to run for large numbers, as it will not be growing exponentially anymore.

The memoizer that was written here is pretty universal and can be used to improve runtime for basically any function.