Tiling a Rectangle with the Fewest Squares

Tiling a Rectangle with the Fewest Squares - Problem

Backtracking Hard

Tiling a Rectangle with the Fewest Squares

You're given a rectangle of dimensions n × m and need to completely tile it using the minimum number of integer-sided squares. Each square can have any integer side length, and squares can be of different sizes.

Goal: Find the minimum number of squares needed to perfectly tile the entire rectangle without gaps or overlaps.

Example: A 2×3 rectangle can be tiled with 3 squares: one 2×2 square and two 1×1 squares.

This is a classic optimization problem that requires exploring different ways to partition the rectangle and finding the most efficient tiling pattern.

Input & Output

example_1.py — Small Rectangle

$ Input: n = 2, m = 3

› Output: 3

💡 Note: We can tile a 2×3 rectangle with 3 squares: one 2×2 square and two 1×1 squares. This is optimal as we cannot do better than 3 squares.

example_2.py — Square Input

$ Input: n = 5, m = 5

› Output: 1

💡 Note: When the rectangle is already a square (5×5), we only need 1 square to tile it completely.

example_3.py — Complex Case

$ Input: n = 11, m = 13

› Output: 6

💡 Note: This is a challenging case that requires careful optimization. The optimal tiling uses 6 squares of various sizes arranged efficiently.

Constraints

1 ≤ n, m ≤ 13
The rectangle dimensions are positive integers
You must tile the entire rectangle without gaps or overlaps

Visualization

Tap to expand

Understanding the Visualization

Initialize Skyline

Start with all column heights at 0, representing empty rectangle

Find Placement

Find leftmost position with minimum height for next square

Try Square Sizes

Attempt squares of all valid sizes at this position

Update and Recurse

Update skyline heights and recursively solve remaining area

Cache Results

Store minimum squares needed for each skyline configuration

Key Takeaway

🎯 Key Insight: By tracking the skyline of placed squares and using memoization, we avoid recalculating the same configurations while systematically exploring all optimal placements.

Asked in

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

The optimal solution uses backtracking with memoization to track the skyline of placed squares. We maintain column heights and systematically try placing squares of different sizes at the leftmost lowest position, using dynamic programming to cache results for identical configurations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n²×m²×2^(n+m))	O(n×m)	Use memoization to avoid recalculating the same subproblems

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a memoization table to store results for rectangle dimensions
For each rectangle, check if result is already computed
If not computed, try all possible cuts (horizontal and vertical)
Store the minimum result in memoization table
Use backtracking for more complex cases with actual square placements

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Heights

Maintain array of column heights representing skyline

Find Minimum

Find leftmost position with minimum height

Try Square Sizes

Try placing squares of different sizes at that position

Memoize Result

Cache the result for this height configuration

Code -

solution.c — C

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

#define MAX_SIZE 20
#define HASH_SIZE 10007

typedef struct HashNode {
    char key[200];
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
int N;

int hash(const char* key) {
    int h = 0;
    for (int i = 0; key[i]; i++) {
        h = (h * 31 + key[i]) % HASH_SIZE;
    }
    return h;
}

int getMemo(const char* key) {
    int h = hash(key);
    HashNode* node = hashTable[h];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return -1;
}

void setMemo(const char* key, int value) {
    int h = hash(key);
    HashNode* node = malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->value = value;
    node->next = hashTable[h];
    hashTable[h] = node;
}

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

int minArray(int* heights, int m) {
    int minVal = heights[0];
    for (int i = 1; i < m; i++) {
        if (heights[i] < minVal) {
            minVal = heights[i];
        }
    }
    return minVal;
}

char* arrayToString(int* heights, int m) {
    static char str[200];
    str[0] = '\0';
    for (int i = 0; i < m; i++) {
        char temp[10];
        sprintf(temp, "%d,", heights[i]);
        strcat(str, temp);
    }
    return str;
}

int dfs(int* heights, int m) {
    char* key = arrayToString(heights, m);
    int cached = getMemo(key);
    if (cached != -1) {
        return cached;
    }
    
    int minH = minArray(heights, m);
    if (minH == N) {
        return 0;
    }
    
    int start = -1;
    for (int i = 0; i < m; i++) {
        if (heights[i] == minH) {
            start = i;
            break;
        }
    }
    
    int end = start;
    while (end < m && heights[end] == minH) {
        end++;
    }
    
    int result = INT_MAX;
    
    for (int size = 1; size <= min(N - minH, end - start); size++) {
        if (start + size <= m) {
            int newHeights[MAX_SIZE];
            for (int i = 0; i < m; i++) {
                newHeights[i] = heights[i];
            }
            for (int i = start; i < start + size; i++) {
                newHeights[i] += size;
            }
            result = min(result, 1 + dfs(newHeights, m));
        }
    }
    
    setMemo(key, result);
    return result;
}

int tilingRectangle(int n, int m) {
    N = n;
    memset(hashTable, 0, sizeof(hashTable));
    int heights[MAX_SIZE] = {0};
    return dfs(heights, m);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²×m²×2^(n+m))

Polynomial states but exponential branching factor in complex cases

⚠ Quadratic Growth

Space Complexity

O(n×m)

Memoization table stores results for all rectangle dimensions

⚡ Linearithmic Space

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

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler