Image Overlap

Image Overlap - Problem

Array Matrix Medium

You are given two images, img1 and img2, represented as binary, square matrices of size n x n. A binary matrix has only 0s and 1s as values.

We translate one image however we choose by sliding all the 1 bits left, right, up, and/or down any number of units. We then place it on top of the other image. We can then calculate the overlap by counting the number of positions that have a 1 in both images.

Note also that a translation does not include any kind of rotation. Any 1 bits that are translated outside of the matrix borders are erased.

Return the largest possible overlap.

Input & Output

Example 1 — Basic Translation

$ Input: img1 = [[1,1,0],[0,1,0],[0,1,0]], img2 = [[0,0,0],[0,1,1],[0,0,1]]

› Output: 3

💡 Note: We translate img1 to the right by 1 unit. After translation: img1[0][1] aligns with img2[0][1], img1[1][1] aligns with img2[1][1], and img1[2][1] aligns with img2[2][1]. Total overlap is 3.

Example 2 — No Translation Needed

$ Input: img1 = [[1]], img2 = [[1]]

› Output: 1

💡 Note: Both images have a single 1 at position (0,0). No translation needed, overlap is 1.

Example 3 — No Overlap Possible

$ Input: img1 = [[0,0],[0,0]], img2 = [[1,1],[1,1]]

› Output: 0

💡 Note: img1 has no 1s, so regardless of translation, there can be no overlap with img2's 1s.

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

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is that we only need to consider positions where 1s exist, not empty positions. We can either try all possible translations (brute force) or focus on 1s coordinates to reduce constant factors. Best approach uses coordinate mapping: Time: O(n⁴), Space: O(n²)

Common Approaches

✓ Focus on 1s Only

⏱️ Time: O(n⁴) Space: O(n²)

Instead of checking all matrix positions, collect coordinates of all 1s in both images. Then for each possible translation, only check if the translated 1s from img1 align with 1s in img2. This reduces the constant factor significantly.

Try All Translations

⏱️ Time: O(n⁴) Space: O(1)

For each possible translation (dx, dy) from -(n-1) to (n-1), shift img1 by that offset and count positions where both images have 1s. This covers all possible ways to slide one image over the other.

Focus on 1s Only — Algorithm Steps

Step 1: Collect all coordinates where img1 and img2 have 1s
Step 2: For each translation offset, count how many 1s from img1 align with 1s from img2
Step 3: Use coordinate mapping to quickly check alignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect 1s

Find all positions with 1s in both images

Calculate Translations

For each pair of 1s, calculate required translation

Count Alignments

Count how many 1s align for each translation

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

typedef struct {
    int dx, dy, count;
} Translation;

int solution(int** img1, int** img2, int n) {
    Point ones1[100], ones2[100];
    int count1 = 0, count2 = 0;
    
    // Collect all 1 positions
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (img1[i][j] == 1) {
                ones1[count1++] = (Point){i, j};
            }
            if (img2[i][j] == 1) {
                ones2[count2++] = (Point){i, j};
            }
        }
    }
    
    if (count1 == 0 || count2 == 0) {
        return 0;
    }
    
    // Count overlaps for each translation
    Translation translations[10000];
    int transCount = 0;
    
    for (int i = 0; i < count1; i++) {
        for (int j = 0; j < count2; j++) {
            int dx = ones2[j].x - ones1[i].x;
            int dy = ones2[j].y - ones1[i].y;
            
            // Find existing translation or create new
            int found = -1;
            for (int k = 0; k < transCount; k++) {
                if (translations[k].dx == dx && translations[k].dy == dy) {
                    found = k;
                    break;
                }
            }
            
            if (found >= 0) {
                translations[found].count++;
            } else {
                translations[transCount++] = (Translation){dx, dy, 1};
            }
        }
    }
    
    int maxOverlap = 0;
    for (int i = 0; i < transCount; i++) {
        if (translations[i].count > maxOverlap) {
            maxOverlap = translations[i].count;
        }
    }
    
    return maxOverlap;
}

int** parseMatrix(char* line, int* n) {
    *n = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && i > 0) (*n)++;
    }
    
    int** matrix = (int**)malloc(*n * sizeof(int*));
    for (int i = 0; i < *n; i++) {
        matrix[i] = (int*)malloc(*n * sizeof(int));
    }
    
    int row = 0, col = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] >= '0' && line[i] <= '1') {
            matrix[row][col++] = line[i] - '0';
            if (col == *n) {
                row++;
                col = 0;
            }
        }
    }
    
    return matrix;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int n1, n2;
    int** img1 = parseMatrix(line1, &n1);
    int** img2 = parseMatrix(line2, &n2);
    
    int result = solution(img1, img2, n1);
    printf("%d\n", result);
    
    for (int i = 0; i < n1; i++) {
        free(img1[i]);
        free(img2[i]);
    }
    free(img1);
    free(img2);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Same worst-case complexity but faster in practice for sparse matrices with few 1s

✓ Linear Growth

Space Complexity

O(n²)

Store coordinates of all 1s in both matrices, worst case is all positions have 1s

✓ Linear Space

58.0K Views

Medium Frequency

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

Focus on 1s Only — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler