Find the Minimum Number of Fibonacci Numbers Whose Sum Is K

Find the Minimum Number of Fibonacci Numbers Whose Sum Is K - Problem

Math Greedy Medium

Given an integer k, find the minimum number of Fibonacci numbers whose sum equals k. The same Fibonacci number can be used multiple times.

The Fibonacci sequence is defined as:

F₁ = 1
F₂ = 1
Fₙ = Fₙ₋₁ + Fₙ₋₂ for n > 2

So the sequence starts: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...

Goal: Return the minimum count of Fibonacci numbers that sum to k.

Note: It's guaranteed that a solution always exists for the given constraints.

Input & Output

example_1.py — Basic case

$ Input: k = 7

› Output: 2

💡 Note: The Fibonacci numbers are: 1, 1, 2, 3, 5, 8, 13, ... We can represent 7 as 5 + 2, which uses 2 Fibonacci numbers. This is optimal since we can't represent 7 with just 1 Fibonacci number.

example_2.py — Perfect Fibonacci

$ Input: k = 10

› Output: 2

💡 Note: We can represent 10 as 8 + 2. Both 8 and 2 are Fibonacci numbers. We use the greedy approach: pick the largest possible (8), then the largest possible from what remains (2).

example_3.py — Small value

$ Input: k = 4

› Output: 2

💡 Note: We can represent 4 as 3 + 1. Although we could also use 2 + 1 + 1, the greedy approach gives us 3 + 1 which uses only 2 numbers and is optimal.

Constraints

1 ≤ k ≤ 10⁹
Note: k can be very large, but there are only ~45 Fibonacci numbers ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Generate Fibonacci Sequence

Create all Fibonacci numbers up to k: [1, 1, 2, 3, 5, 8, 13, 21, 34, ...]

Pick Largest Possible

Always choose the biggest Fibonacci number that doesn't exceed remaining k

Subtract and Repeat

Reduce k by chosen number and increment counter, repeat until k = 0

Return Count

The counter holds the minimum number of Fibonacci numbers needed

Key Takeaway

🎯 Key Insight: Fibonacci numbers have the unique property that F(n+1) > F(n) + F(n-1) + ... + F(1), making the greedy approach optimal!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy approach: generate all Fibonacci numbers up to k, then repeatedly pick the largest possible Fibonacci number ≤ remaining sum. This works because of Fibonacci's special mathematical property and runs in O(log k) time.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(log k)	O(log k)	Always pick the largest Fibonacci number ≤ remaining sum
Brute Force (Dynamic Programming)	O(k * F)	O(k)	Try all possible combinations using DP to find minimum count

Greedy Approach (Optimal) — Algorithm Steps

Generate all Fibonacci numbers up to k in ascending order
Initialize count = 0 and remaining = k
While remaining > 0:
Find the largest Fibonacci number ≤ remaining
Subtract it from remaining and increment count
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Fibonacci

Create sequence: 1, 1, 2, 3, 5, 8, 13, 21...

Pick Largest ≤ k

Find biggest Fibonacci number that fits

Subtract & Repeat

Remove it from k and increment counter

Continue Until k=0

Keep picking largest possible until done

Code -

solution.c — C

int findMinFibonacciNumbers(int k) {
    // Generate Fibonacci numbers up to k
    int fibs[50];  // Max needed for given constraints
    int fib_count = 0;
    int a = 1, b = 1;
    while (a <= k) {
        fibs[fib_count++] = a;
        int temp = a + b;
        a = b;
        b = temp;
    }
    
    // Greedy approach: always pick largest possible
    int count = 0;
    int i = fib_count - 1;  // Start from largest
    
    while (k > 0) {
        // Find largest Fibonacci number <= k
        while (fibs[i] > k) {
            i--;
        }
        
        // Use this Fibonacci number
        k -= fibs[i];
        count++;
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(log k)

We generate O(log k) Fibonacci numbers, then make at most O(log k) greedy choices. Each Fibonacci number roughly doubles, so there are logarithmically many.

⚡ Linearithmic

Space Complexity

O(log k)

We store the Fibonacci numbers up to k, which requires O(log k) space since Fibonacci numbers grow exponentially.

✓ Linear Space

38.2K Views

Medium Frequency

~12 min Avg. Time

1.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler