Count Cells in Overlapping Horizontal and Vertical Substrings

Count Cells in Overlapping Horizontal and Vertical Substrings - Problem

You are given an m x n matrix grid consisting of characters and a string pattern.

A horizontal substring is a contiguous sequence of characters read from left to right. If the end of a row is reached before the substring is complete, it wraps to the first column of the next row and continues as needed. You do not wrap from the bottom row back to the top.

A vertical substring is a contiguous sequence of characters read from top to bottom. If the bottom of a column is reached before the substring is complete, it wraps to the first row of the next column and continues as needed. You do not wrap from the last column back to the first.

Count the number of cells in the matrix that satisfy the following condition: The cell must be part of at least one horizontal substring and at least one vertical substring, where both substrings are equal to the given pattern.

Return the count of these cells.

Input & Output

Example 1 — Basic Pattern Match

$ Input: grid = [["a","b"],["b","a"]], pattern = "ab"

› Output: 1

💡 Note: Horizontal "ab" at (0,0)→(0,1) and vertical "ab" at (0,0)→(1,0). Cell (0,0) is in both patterns.

Example 2 — No Overlap

$ Input: grid = [["a","b"],["c","d"]], pattern = "ab"

› Output: 0

💡 Note: Horizontal "ab" exists at (0,0)→(0,1) but no vertical "ab" pattern, so no overlapping cells.

Example 3 — Multiple Overlaps

$ Input: grid = [["x","y"],["x","y"]], pattern = "xy"

› Output: 2

💡 Note: Both rows contain "xy" horizontally, both columns contain "xy" vertically. Cells (0,0) and (0,1) are in both.

Constraints

1 ≤ m, n ≤ 10³
1 ≤ pattern.length ≤ 10³
grid[i][j] and pattern consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to find cells that participate in both horizontal and vertical pattern matches. Best approach uses two-pass scanning with hash sets for O(m·n·k) time and efficient set intersection. Time: O(m·n·k), Space: O(m·n)

Common Approaches

✓ Brute Force - Check All Positions

⏱️ Time: O(m·n·k²) Space: O(m·n)

Check every possible starting position for horizontal and vertical substrings. For each cell, verify if it belongs to valid pattern matches in both directions.

Optimized - Two-Pass with Sets

⏱️ Time: O(m·n·k) Space: O(m·n)

First pass collects all cells that are part of horizontal pattern matches. Second pass collects all cells that are part of vertical pattern matches. Then find intersection efficiently using set operations.

Brute Force - Check All Positions — Algorithm Steps

Find all horizontal pattern matches with their cell positions
Find all vertical pattern matches with their cell positions
Count cells that appear in both horizontal and vertical matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Horizontal

Find all horizontal pattern matches

Scan Vertical

Find all vertical pattern matches

Count Overlap

Count cells in both sets

Code -

solution.c — C

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

#define MAX_SIZE 1000

int solution(char grid[][MAX_SIZE], int m, int n, char* pattern) {
    int k = strlen(pattern);
    if (k == 0) return 0;
    
    char horizontalCells[MAX_SIZE*MAX_SIZE][20];
    char verticalCells[MAX_SIZE*MAX_SIZE][20];
    int hCount = 0, vCount = 0;
    
    // Find horizontal matches
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            char substring[MAX_SIZE];
            char positions[MAX_SIZE][20];
            int posCount = 0;
            int row = i, col = j;
            int idx = 0;
            
            for (int pos = 0; pos < k; pos++) {
                if (row >= m) break;
                substring[idx++] = grid[row][col];
                sprintf(positions[posCount++], "%d,%d", row, col);
                col++;
                if (col == n) {
                    col = 0;
                    row++;
                }
            }
            substring[idx] = '\0';
            
            if (strlen(substring) == k && strcmp(substring, pattern) == 0) {
                for (int p = 0; p < posCount; p++) {
                    strcpy(horizontalCells[hCount++], positions[p]);
                }
            }
        }
    }
    
    // Find vertical matches
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < m; i++) {
            char substring[MAX_SIZE];
            char positions[MAX_SIZE][20];
            int posCount = 0;
            int row = i, col = j;
            int idx = 0;
            
            for (int pos = 0; pos < k; pos++) {
                if (col >= n) break;
                substring[idx++] = grid[row][col];
                sprintf(positions[posCount++], "%d,%d", row, col);
                row++;
                if (row == m) {
                    row = 0;
                    col++;
                }
            }
            substring[idx] = '\0';
            
            if (strlen(substring) == k && strcmp(substring, pattern) == 0) {
                for (int p = 0; p < posCount; p++) {
                    strcpy(verticalCells[vCount++], positions[p]);
                }
            }
        }
    }
    
    // Count intersection - remove duplicates first
    int count = 0;
    char counted[MAX_SIZE*MAX_SIZE][20];
    int countedSize = 0;
    
    for (int i = 0; i < hCount; i++) {
        for (int j = 0; j < vCount; j++) {
            if (strcmp(horizontalCells[i], verticalCells[j]) == 0) {
                // Check if already counted
                int alreadyCounted = 0;
                for (int k = 0; k < countedSize; k++) {
                    if (strcmp(counted[k], horizontalCells[i]) == 0) {
                        alreadyCounted = 1;
                        break;
                    }
                }
                if (!alreadyCounted) {
                    strcpy(counted[countedSize++], horizontalCells[i]);
                    count++;
                }
                break;
            }
        }
    }
    return count;
}

int main() {
    char grid[MAX_SIZE][MAX_SIZE];
    char pattern[MAX_SIZE];
    char line[10000];
    int m = 0, n = 0;
    
    // Read grid line
    fgets(line, sizeof(line), stdin);
    
    // Parse grid - extract characters between quotes
    int i = 0, j = 0;
    int inQuote = 0;
    char currentChar = 0;
    
    for (int pos = 0; line[pos] != '\0' && line[pos] != '\n'; pos++) {
        if (line[pos] == '"') {
            if (inQuote) {
                // End of character, store it
                if (currentChar != 0) {
                    grid[i][j] = currentChar;
                    j++;
                    currentChar = 0;
                }
                inQuote = 0;
            } else {
                inQuote = 1;
            }
        } else if (inQuote && line[pos] >= 'a' && line[pos] <= 'z') {
            currentChar = line[pos];
        } else if (line[pos] == ']' && line[pos+1] == ',' && line[pos+2] == '[') {
            // End of row
            if (j > 0) {
                if (n == 0) n = j;  // Set n from first row
                i++;
                j = 0;
            }
        }
    }
    // Handle last row
    if (j > 0) {
        if (n == 0) n = j;
        i++;
    }
    m = i;
    
    // Read pattern line
    fgets(pattern, sizeof(pattern), stdin);
    pattern[strcspn(pattern, "\n")] = 0;
    
    int result = solution(grid, m, n, pattern);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m·n·k²)

For each of m·n cells, check up to k positions in both directions where k is pattern length

✓ Linear Growth

Space Complexity

O(m·n)

Storage for marking cells that are part of horizontal and vertical matches

⚡ Linearithmic Space

12.8K Views

Medium Frequency

~35 min Avg. Time

234 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

Brute Force - Check All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler