Memoized Function - Problem

Implement a function with memoization to efficiently calculate the Nth Fibonacci number.

The Fibonacci sequence is defined as:

F(0) = 0
F(1) = 1
F(n) = F(n-1) + F(n-2) for n > 1

Your function should use memoization to store previously calculated values and avoid redundant computations.

Input: An integer n (0 ≤ n ≤ 100)

Output: The Nth Fibonacci number

Input & Output

Example 1 — Small Number

$ Input: n = 5

› Output: 5

💡 Note: F(5) = F(4) + F(3) = 3 + 2 = 5. The sequence is: 0, 1, 1, 2, 3, 5

Example 2 — Base Case

$ Input: n = 0

› Output: 0

💡 Note: F(0) = 0 by definition

Example 3 — Another Base Case

$ Input: n = 1

› Output: 1

💡 Note: F(1) = 1 by definition

Constraints

0 ≤ n ≤ 100
Result fits in 64-bit integer

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is using memoization to cache previously calculated Fibonacci values, eliminating redundant recursive calls. The optimal approach uses space-optimized dynamic programming with only two variables, achieving O(n) time and O(1) space complexity.

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n) Space: O(n)

Build the solution iteratively from the bottom up, starting with base cases and computing each Fibonacci number exactly once. This eliminates recursion overhead and uses optimal space.

Naive Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

Calculate Fibonacci numbers using the mathematical definition directly with recursion. Each call spawns two more recursive calls, leading to exponential time complexity due to repeated calculations.

Space-Optimized DP

⏱️ Time: O(n) Space: O(1)

Since each Fibonacci number only depends on the two previous numbers, we only need to keep track of the last two values instead of storing the entire array. This reduces space complexity to O(1).

Top-Down Memoization

⏱️ Time: O(n) Space: O(n)

Use a hash map or array to store previously calculated Fibonacci values. Before making recursive calls, check if the result is already cached. This transforms exponential time complexity to linear.

Bottom-Up Dynamic Programming — Algorithm Steps

Handle base cases for n=0 and n=1
Create array to store intermediate results
Fill array iteratively: dp[i] = dp[i-1] + dp[i-2]
Return final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base cases dp[0]=0, dp[1]=1

Fill Array

Calculate dp[i] = dp[i-1] + dp[i-2]

Return Result

dp[n] contains the answer

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

long long solution(int n) {
    if (n <= 1) {
        return n;
    }
    
    long long* dp = (long long*)malloc((n + 1) * sizeof(long long));
    dp[0] = 0;
    dp[1] = 1;
    
    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    
    long long result = dp[n];
    free(dp);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    long long result = solution(n);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop from 2 to n, each iteration does constant work

✓ Linear Growth

Space Complexity

O(n)

Array of size n+1 to store all Fibonacci values

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Memoized Function - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler