Matrix Exponentiation - Problem

Given a positive integer n, compute the Nth Fibonacci number using matrix exponentiation in O(log n) time complexity.

The Fibonacci sequence is defined as:

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

Your task is to implement an efficient solution that can handle large values of n by using matrix exponentiation instead of the naive recursive or iterative approaches.

Key insight: The Fibonacci recurrence can be represented as matrix multiplication, and we can use fast matrix exponentiation to achieve logarithmic time complexity.

Input & Output

Example 1 — Small Fibonacci Number

$ Input: n = 5

› Output: 5

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

Example 2 — Base Cases

$ Input: n = 0

› Output: 0

💡 Note: F(0) = 0 by definition, this is the first Fibonacci number

Example 3 — Larger Fibonacci Number

$ Input: n = 10

› Output: 55

💡 Note: F(10) = 55. Matrix exponentiation computes this efficiently in O(log 10) time instead of O(10) linear time

Constraints

0 ≤ n ≤ 50
n is a non-negative integer

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 M Microsoft 15 a Amazon 12

The key insight is representing the Fibonacci recurrence as matrix multiplication: [[F(n+1), F(n)] = [F(n), F(n-1)] * [[1,1],[1,0]]. Best approach uses matrix exponentiation with binary exponentiation to compute the result. Time: O(log n), Space: O(log n)

Common Approaches

✓ Dynamic Programming

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

Build the Fibonacci sequence iteratively from F(0) to F(n), storing each value to avoid recomputation. Uses O(n) time and O(1) space with rolling variables.

Matrix Exponentiation

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

Express Fibonacci recurrence as matrix multiplication: [[F(n+1), F(n)] = [F(n), F(n-1)] * [[1,1],[1,0]]. Use fast exponentiation to compute the matrix power in O(log n) time.

Naive Recursion

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

Directly implement the Fibonacci definition: F(n) = F(n-1) + F(n-2). This creates a binary tree of recursive calls that recomputes the same values multiple times.

Dynamic Programming — Algorithm Steps

Step 1: Handle base cases F(0)=0, F(1)=1
Step 2: Use two variables to track previous two Fibonacci numbers
Step 3: Iterate from 2 to n, updating variables with F(i-1) + F(i-2)
Step 4: Return the final computed value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with F(0)=0, F(1)=1

Iterate

Build each F(i) = F(i-1) + F(i-2)

Result

Reach F(n) in n steps

Code -

solution.c — C

#include <stdio.h>

long long solution(int n) {
    if (n <= 1) {
        return n;
    }
    
    long long prev2 = 0, prev1 = 1;
    for (int i = 2; i <= n; i++) {
        long long current = prev1 + prev2;
        prev2 = prev1;
        prev1 = current;
    }
    
    return prev1;
}

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

⚡ Linearithmic

Space Complexity

O(1)

Only uses two variables to track previous values

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~35 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

Matrix Exponentiation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler