Count Cells in Overlapping Horizontal and Vertical Substrings

Count Cells in Overlapping Horizontal and Vertical Substrings - Problem

You are given an m × n matrix grid consisting of characters and a pattern string. Your task is to find cells that are part of both a horizontal and vertical occurrence of the pattern.

Horizontal Reading: Read characters from left to right. When you reach the end of a row, wrap to the first column of the next row and continue. You cannot wrap from the last row back to the first.

Vertical Reading: Read characters from top to bottom. When you reach the bottom of a column, wrap to the first row of the next column and continue. You cannot wrap from the last column back to the first.

Goal: Count cells that belong to at least one horizontal substring AND at least one vertical substring, where both substrings match the given pattern.

Example: If pattern = "AB" and we find "AB" horizontally starting at (0,0) and "AB" vertically starting at (0,0), then cell (0,0) contributes to our count since it's part of both occurrences.

Input & Output

example_1.py — Basic Example

$ Input: grid = [["A","B","C"],["D","A","B"]], pattern = "AB"

› Output: 2

💡 Note: Horizontal: "AB" found at positions (0,0)-(0,1). Vertical: "AB" found at positions (1,1)-(0,2) with wrapping. Cell (0,1) is part of both matches, contributing to count.

example_2.py — No Overlaps

$ Input: grid = [["A","B"],["C","D"]], pattern = "AC"

› Output: 0

💡 Note: "AC" found horizontally starting at (0,0) with wrapping to (1,0). "AC" not found vertically. No cells are part of both horizontal and vertical matches.

example_3.py — Multiple Overlaps

$ Input: grid = [["X","Y","X"],["Y","X","Y"]], pattern = "XY"

› Output: 3

💡 Note: Multiple "XY" patterns found both horizontally and vertically. Several cells participate in both types of matches, resulting in count of 3.

Visualization

Tap to expand

Understanding the Visualization

Understand Wrapping

Horizontal reading wraps from end of row to start of next row. Vertical reading wraps from bottom of column to top of next column.

Find Horizontal Matches

Search for the pattern in the horizontally linearized string and track which matrix cells are involved.

Find Vertical Matches

Search for the pattern in the vertically linearized string and track which matrix cells are involved.

Count Overlaps

Find cells that appear in both horizontal and vertical match sets - these are our answer.

Key Takeaway

🎯 Key Insight: By linearizing the matrix reading patterns and using efficient string matching algorithms, we can solve this problem optimally in O(m×n + p) time rather than the naive O(m×n×p) approach.

Time & Space Complexity

Time Complexity

⏱️

O(m*n + p)

KMP preprocessing is O(p), searching in linearized strings is O(m*n), total is O(m*n + p)

✓ Linear Growth

Space Complexity

O(m*n + p)

Space for linearized strings O(m*n) plus KMP failure function O(p)

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 100 (matrix dimensions)
1 ≤ pattern.length ≤ m × n
grid[i][j] and pattern consist of lowercase English letters only
Pattern length does not exceed total matrix size
No empty inputs: grid, pattern are non-empty

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses KMP string matching algorithm to efficiently find all horizontal and vertical pattern occurrences in O(m×n + p) time. By linearizing the matrix into horizontal and vertical strings, we can leverage advanced string matching techniques and then map results back to matrix coordinates to count overlapping cells.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized String Matching (KMP Algorithm)	O(m*n + p)	O(m*n + p)	Use KMP algorithm to efficiently find all pattern occurrences in linearized horizontal and vertical strings
Brute Force (Check All Positions)	O(mnp)	O(m*n)	Check every possible starting position for horizontal and vertical patterns, then find overlapping cells

Optimized String Matching (KMP Algorithm) — Algorithm Steps

Create horizontal string by concatenating all rows with wrapping
Create vertical string by concatenating all columns with wrapping
Use KMP algorithm to find all pattern occurrences in horizontal string
Convert horizontal match positions back to matrix coordinates
Use KMP algorithm to find all pattern occurrences in vertical string
Convert vertical match positions back to matrix coordinates
Count cells that appear in both horizontal and vertical matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Linearize Matrix

Convert 2D matrix to 1D strings for horizontal and vertical reading

KMP Search

Use KMP algorithm to find all pattern occurrences efficiently

Map Back

Convert linear positions back to matrix coordinates

Find Intersection

Count cells that appear in both horizontal and vertical matches

Code -

solution.c — C

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

#define MAX_SIZE 10000

int* buildKMPTable(char* pattern, int patternLen) {
    int* table = (int*)calloc(patternLen, sizeof(int));
    int j = 0;
    for (int i = 1; i < patternLen; i++) {
        while (j > 0 && pattern[i] != pattern[j]) {
            j = table[j - 1];
        }
        if (pattern[i] == pattern[j]) {
            j++;
        }
        table[i] = j;
    }
    return table;
}

int* kmpSearch(char* text, char* pattern, int* table, int* matchCount) {
    int textLen = strlen(text);
    int patternLen = strlen(pattern);
    int* matches = (int*)malloc(MAX_SIZE * sizeof(int));
    *matchCount = 0;
    
    int j = 0;
    for (int i = 0; i < textLen; i++) {
        while (j > 0 && text[i] != pattern[j]) {
            j = table[j - 1];
        }
        if (text[i] == pattern[j]) {
            j++;
        }
        if (j == patternLen) {
            matches[(*matchCount)++] = i - j + 1;
            j = table[j - 1];
        }
    }
    return matches;
}

int countCellsInOverlappingSubstrings(char** grid, int gridSize, int* gridColSize, char* pattern) {
    if (gridSize == 0 || gridColSize[0] == 0 || strlen(pattern) == 0) {
        return 0;
    }
    
    int m = gridSize, n = gridColSize[0], p = strlen(pattern);
    
    int* kmpTable = buildKMPTable(pattern, p);
    
    // Create horizontal string
    char* horizontalStr = (char*)malloc((m * n + 1) * sizeof(char));
    int idx = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            horizontalStr[idx++] = grid[i][j];
        }
    }
    horizontalStr[idx] = '\0';
    
    // Create vertical string
    char* verticalStr = (char*)malloc((m * n + 1) * sizeof(char));
    idx = 0;
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < m; i++) {
            verticalStr[idx++] = grid[i][j];
        }
    }
    verticalStr[idx] = '\0';
    
    // Find horizontal matches
    int hMatchCount;
    int* horizontalMatches = kmpSearch(horizontalStr, pattern, kmpTable, &hMatchCount);
    
    typedef struct {
        int row, col;
    } Cell;
    
    Cell horizontalCells[MAX_SIZE];
    int hCellCount = 0;
    
    for (int i = 0; i < hMatchCount; i++) {
        for (int k = 0; k < p; k++) {
            int pos = horizontalMatches[i] + k;
            if (pos < m * n) {
                int row = pos / n;
                int col = pos % n;
                if (row < m) {
                    horizontalCells[hCellCount].row = row;
                    horizontalCells[hCellCount].col = col;
                    hCellCount++;
                }
            }
        }
    }
    
    // Find vertical matches
    int vMatchCount;
    int* verticalMatches = kmpSearch(verticalStr, pattern, kmpTable, &vMatchCount);
    
    Cell verticalCells[MAX_SIZE];
    int vCellCount = 0;
    
    for (int i = 0; i < vMatchCount; i++) {
        for (int k = 0; k < p; k++) {
            int pos = verticalMatches[i] + k;
            if (pos < m * n) {
                int col = pos / m;
                int row = pos % m;
                if (col < n) {
                    verticalCells[vCellCount].row = row;
                    verticalCells[vCellCount].col = col;
                    vCellCount++;
                }
            }
        }
    }
    
    // Count overlapping cells
    int count = 0;
    bool visited[MAX_SIZE] = {false};
    
    for (int i = 0; i < hCellCount; i++) {
        if (visited[i]) continue;
        for (int j = 0; j < vCellCount; j++) {
            if (horizontalCells[i].row == verticalCells[j].row &&
                horizontalCells[i].col == verticalCells[j].col) {
                count++;
                visited[i] = true;
                break;
            }
        }
    }
    
    free(kmpTable);
    free(horizontalStr);
    free(verticalStr);
    free(horizontalMatches);
    free(verticalMatches);
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n + p)

KMP preprocessing is O(p), searching in linearized strings is O(m*n), total is O(m*n + p)

✓ Linear Growth

Space Complexity

O(m*n + p)

Space for linearized strings O(m*n) plus KMP failure function O(p)

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 100 (matrix dimensions)
1 ≤ pattern.length ≤ m × n
grid[i][j] and pattern consist of lowercase English letters only
Pattern length does not exceed total matrix size
No empty inputs: grid, pattern are non-empty

43.7K Views

Medium-High Frequency

~25 min Avg. Time

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

Optimized String Matching (KMP Algorithm) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler