Tiling a Rectangle with the Fewest Squares

Tiling a Rectangle with the Fewest Squares - Problem

Backtracking Hard

Given a rectangle of size n × m, return the minimum number of integer-sided squares that can tile the rectangle completely.

You need to find the optimal way to divide the rectangle into squares such that:

All squares have integer side lengths
The squares completely cover the rectangle without overlapping
The total number of squares is minimized

Example: A 2×3 rectangle can be tiled with 3 squares of size 1×1, or with other combinations, but we want the minimum count.

Input & Output

Example 1 — Square Case

$ Input: n = 2, m = 2

› Output: 1

💡 Note: A 2×2 rectangle is already a perfect square, so we need only 1 square of size 2×2

Example 2 — Small Rectangle

$ Input: n = 2, m = 3

› Output: 3

💡 Note: We can tile the 2×3 rectangle with 3 squares: one 2×2 square and two 1×1 squares, or three 2×1 rectangles each made of two 1×1 squares. The minimum is 3 squares total.

Example 3 — Larger Rectangle

$ Input: n = 5, m = 8

› Output: 5

💡 Note: The 5×8 rectangle can be optimally tiled with 5 squares. One approach: one 5×5 square and four smaller squares to cover the remaining 5×3 area.

Constraints

1 ≤ n, m ≤ 13
Answer will be a positive integer

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 F Facebook 8

The key insight is to use recursive backtracking with memoization to try all possible cuts. We can make horizontal or vertical cuts at any position and recursively solve the resulting subproblems. Best approach is memoized recursion with pruning for optimal performance. Time: O(n²×m²), Space: O(n×m)

Common Approaches

✓ Memoized Recursion

⏱️ Time: O(n²×m²) Space: O(n×m)

Same recursive approach but store results of previously computed rectangle dimensions in a memoization table. This prevents solving the same subproblem multiple times.

Optimized Backtracking with Pruning

⏱️ Time: O(n²×m²) Space: O(n×m)

Improved backtracking that uses bounds checking to prune unpromising branches early. Also ensures smaller dimension is first to reduce duplicate calculations.

Recursive Backtracking

⏱️ Time: O(2^(n+m)) Space: O(n+m)

For each rectangle, try making horizontal and vertical cuts at every possible position. Recursively solve the resulting smaller rectangles and take the minimum total squares needed.

Memoized Recursion — Algorithm Steps

Step 1: Check if result for current n,m is already cached
Step 2: If cached, return stored result immediately
Step 3: Otherwise, compute using recursive approach with all cuts
Step 4: Store result in cache before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

First Call

Calculate result for new rectangle size

Cache Result

Store result in memoization table

Reuse

Return cached result for repeated dimensions

Code -

solution.c — C

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

int memo[15][15];
int visited[15][15];

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

int dp(int n, int m) {
    if (n == m) {
        return 1;
    }
    
    if (n > m) {
        int temp = n;
        n = m;
        m = temp;
    }
    
    if (visited[n][m]) {
        return memo[n][m];
    }
    
    int result = INT_MAX;
    
    // Try horizontal cuts
    for (int i = 1; i < n; i++) {
        result = min(result, dp(i, m) + dp(n - i, m));
    }
    
    // Try vertical cuts
    for (int j = 1; j < m; j++) {
        result = min(result, dp(n, j) + dp(n, m - j));
    }
    
    memo[n][m] = result;
    visited[n][m] = 1;
    return result;
}

int solution(int n, int m) {
    memset(visited, 0, sizeof(visited));
    return dp(n, m);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²×m²)

Each unique (n,m) pair computed once, with O(n+m) cuts to try

✓ Linear Growth

Space Complexity

O(n×m)

Memoization table stores results for all subproblems

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Memoized Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler