Image Overlap - Practice Coding Problems

Image Overlap - Problem

Array Matrix Medium

Imagine you have two binary images represented as square matrices filled with 0s and 1s. Your task is to find the maximum overlap between these images by sliding one image over the other.

You can translate (slide) one image in any direction - left, right, up, or down - by any number of units. Think of it like placing a transparent sheet with holes (1s represent holes, 0s represent solid areas) over another sheet, and counting how many holes align perfectly.

Key Rules:

Only translation is allowed - no rotation
Any 1s that slide outside the matrix boundaries are lost
Overlap occurs when both images have a 1 at the same position
Return the maximum possible overlap count

This problem tests your ability to work with 2D transformations and efficiently explore all possible alignments.

Input & Output

example_1.py — Basic Overlap

$ Input: A = [[1,1,0],[0,1,0],[0,1,0]], B = [[0,0,0],[0,1,1],[0,0,1]]

› Output: 3

💡 Note: We translate image A by sliding it right by 1 unit and down by 1 unit. This aligns A's 1s at positions (0,0),(0,1),(1,1),(2,1) with B's 1s at positions (1,1),(1,2),(2,2), creating overlaps at (1,1), (1,2), and (2,2) for a total of 3.

example_2.py — No Overlap Possible

$ Input: A = [[1]], B = [[1]]

› Output: 1

💡 Note: Both matrices have a single 1 at position (0,0). With no translation (offset 0,0), they overlap perfectly with 1 matching position.

example_3.py — Zero Matrix Edge Case

$ Input: A = [[0,0],[0,0]], B = [[1,1],[1,1]]

› Output: 0

💡 Note: Matrix A has no 1s, so regardless of how we translate it, there can be no overlapping 1s. The maximum overlap is 0.

Visualization

Tap to expand

Understanding the Visualization

Identify Star Positions

Mark all star cutout positions on both transparencies

Calculate Alignment Offsets

For each star on the first transparency, calculate how to align it with each star on the second

Count Offset Frequencies

Track which alignment offset would create the most star alignments

Find Optimal Translation

The most common offset gives the maximum number of aligned stars

Key Takeaway

🎯 Key Insight: Instead of trying all O(n²) possible translations, focus only on the O(k²) meaningful offsets that could align at least one pair of 1s, where k is the number of 1s in the matrices.

Time & Space Complexity

Time Complexity

⏱️

O(k²)

k is the number of 1s in the matrices. We compare each 1 in A with each 1 in B

✓ Linear Growth

Space Complexity

O(k)

Store coordinates of all 1s and frequency map of offsets

✓ Linear Space

Constraints

n == img1.length == img1[i].length
n == img2.length == img2[i].length
1 ≤ n ≤ 30
img1[i][j] is either 0 or 1
img2[i][j] is either 0 or 1

Asked in

G Google 35 ⊞ Microsoft 28 f Facebook 22 Apple 15

The optimal approach uses coordinate mapping to avoid checking meaningless positions. First, collect all coordinates where each matrix has 1s. Then, for each pair of 1s between the matrices, calculate the required translation offset and count frequencies. The most frequent offset represents the maximum possible overlap, reducing time complexity from O(n⁴) to O(k²) where k is the number of 1s.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Coordinate Mapping	O(k²)	O(k)	Collect all 1-positions first, then count frequency of meaningful offsets
Brute Force (Try All Translations)	O(n⁴)	O(1)	Try every possible translation offset and count overlaps

Two-Pass Coordinate Mapping — Algorithm Steps

Collect all coordinates (i,j) where A[i][j] = 1 into list onesA
Collect all coordinates (i,j) where B[i][j] = 1 into list onesB
For each position in onesA and each position in onesB, calculate the required offset
Use a hash map to count frequency of each offset
Return the maximum frequency found (which represents maximum overlap)

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Coordinates

Find all positions where each matrix has 1s

Calculate Offsets

For each pair of 1s, calculate the translation offset needed

Count Frequencies

Count how many times each offset appears

Find Maximum

The most frequent offset gives the maximum overlap

Code -

solution.c — C

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

#define MAX_COORDS 100
#define MAX_OFFSETS 10000

typedef struct {
    int x, y;
} Coord;

typedef struct {
    char offset[20];
    int count;
} OffsetCount;

int largestOverlap(int** A, int ASize, int* AColSize, int** B, int BSize, int* BColSize) {
    int n = ASize;
    
    // First pass: collect all 1-positions
    Coord onesA[MAX_COORDS], onesB[MAX_COORDS];
    int countA = 0, countB = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (A[i][j] == 1) {
                onesA[countA++] = (Coord){i, j};
            }
            if (B[i][j] == 1) {
                onesB[countB++] = (Coord){i, j};
            }
        }
    }
    
    // Second pass: count offset frequencies
    OffsetCount offsets[MAX_OFFSETS];
    int offsetCount = 0;
    
    for (int i = 0; i < countA; i++) {
        for (int j = 0; j < countB; j++) {
            char offset[20];
            sprintf(offset, "%d,%d", onesB[j].x - onesA[i].x, onesB[j].y - onesA[i].y);
            
            // Find or create offset entry
            int found = -1;
            for (int k = 0; k < offsetCount; k++) {
                if (strcmp(offsets[k].offset, offset) == 0) {
                    found = k;
                    break;
                }
            }
            
            if (found >= 0) {
                offsets[found].count++;
            } else {
                strcpy(offsets[offsetCount].offset, offset);
                offsets[offsetCount].count = 1;
                offsetCount++;
            }
        }
    }
    
    // Return maximum frequency
    int maxOverlap = 0;
    for (int i = 0; i < offsetCount; i++) {
        if (offsets[i].count > maxOverlap) {
            maxOverlap = offsets[i].count;
        }
    }
    return maxOverlap;
}

int main() {
    // Parse input and call largestOverlap
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k²)

k is the number of 1s in the matrices. We compare each 1 in A with each 1 in B

✓ Linear Growth

Space Complexity

O(k)

Store coordinates of all 1s and frequency map of offsets

✓ Linear Space

Constraints

n == img1.length == img1[i].length
n == img2.length == img2[i].length
1 ≤ n ≤ 30
img1[i][j] is either 0 or 1
img2[i][j] is either 0 or 1

28.5K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Coordinate Mapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler