Perfect Squares

Perfect Squares - Problem

Given an integer n, return the least number of perfect square numbers that sum to n.

A perfect square is an integer that is the square of an integer; in other words, it is the product of some integer with itself. For example, 1, 4, 9, and 16 are perfect squares while 3 and 11 are not.

Input & Output

Example 1 — Basic Case

$ Input: n = 12

› Output: 3

💡 Note: 12 = 4 + 4 + 4. We need 3 perfect squares (each is 2²), so return 3.

Example 2 — Single Square

$ Input: n = 13

› Output: 2

💡 Note: 13 = 9 + 4 = 3² + 2². We need 2 perfect squares, so return 2.

Example 3 — Already Perfect Square

$ Input: n = 16

› Output: 1

💡 Note: 16 = 4² is already a perfect square, so we need only 1 perfect square.

Constraints

1 ≤ n ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 25 M Microsoft 20

The key insight is that this is a classic dynamic programming problem where each number can be built optimally from smaller perfect squares. Best approach is Bottom-Up DP which builds solutions iteratively. Time: O(n√n), Space: O(n)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Create a DP array where dp[i] represents the minimum number of perfect squares that sum to i. Build the solution iteratively from 1 to n.

Breadth-First Search

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

Treat this as a graph problem where each number is a node, and we can move from i to i+square for any perfect square. Use BFS to find shortest path from 0 to n.

Memoization (Top-Down DP)

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

Same recursive approach but store results in a memo table to avoid recalculating the same subproblems multiple times.

Recursive Brute Force

⏱️ Time: O(n^(n/2)) Space: O(n)

For each number, try subtracting every possible perfect square and recursively solve for the remainder. Take the minimum across all possibilities.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize dp[0] = 0
For each number i from 1 to n, try all perfect squares ≤ i
dp[i] = min(dp[i - square] + 1) for all squares

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0] = 0, others to infinity

Fill Table

For each i, try all squares ≤ i

Result

dp[n] contains minimum squares needed

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int n) {
    if (n <= 0) return 0;
    
    // dp[i] = minimum number of perfect squares that sum to i
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    
    dp[0] = 0;
    for (int i = 1; i <= n; i++) {
        dp[i] = INT_MAX;
    }
    
    // For each number from 1 to n
    for (int i = 1; i <= n; i++) {
        // Try all perfect squares <= i
        for (int j = 1; j * j <= i; j++) {
            int square = j * j;
            dp[i] = min(dp[i], dp[i - square] + 1);
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n√n)

Outer loop runs n times, inner loop runs √n times for each n

✓ Linear Growth

Space Complexity

O(n)

DP array stores minimum squares needed for each number 0 to n

⚡ Linearithmic Space

67.0K Views

High Frequency

~25 min Avg. Time

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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler