Equal Row and Column Pairs - Practice Coding Problems

Equal Row and Column Pairs - Problem

Matrix Row-Column Matching Challenge

Given an n × n integer matrix grid, your task is to find how many row-column pairs are identical. A row and column pair (ri, cj) is considered equal if they contain the exact same elements in the same order.

Think of it like finding matching patterns - you're comparing each horizontal line (row) with each vertical line (column) to see if they're mirror images of each other in terms of their values.

Example: If row 0 is [3,2,1] and column 1 is also [3,2,1] (reading top to bottom), that's one matching pair!

Goal: Return the total count of such matching pairs.

Input & Output

example_1.py — Basic Matrix

$ Input: grid = [[3,2,1],[1,7,6],[2,7,7]]

› Output: 1

💡 Note: Row 2 [2,7,7] matches Column 1 [2,7,7]. This is the only matching pair, so we return 1.

example_2.py — Multiple Matches

$ Input: grid = [[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]]

› Output: 3

💡 Note: Row 2 [2,4,2,2] and Row 3 [2,4,2,2] both match Column 2 [2,4,2,2]. So we have pairs (2,2), (3,2), plus one more match making 3 total.

example_3.py — No Matches

$ Input: grid = [[1,2],[3,4]]

› Output: 0

💡 Note: Row 0 [1,2] ≠ Column 0 [1,3], Row 0 [1,2] ≠ Column 1 [2,4], Row 1 [3,4] ≠ Column 0 [1,3], Row 1 [3,4] ≠ Column 1 [2,4]. No pairs match.

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 200
1 ≤ grid[i][j] ≤ 10⁵
The matrix is always square (n × n)

Visualization

Tap to expand

Understanding the Visualization

Catalog Shelves

Record every horizontal shelf pattern in a catalog with frequencies

Check Towers

For each vertical tower, look it up in your shelf catalog

Count Matches

Add the frequency of matching shelf patterns to your total

Final Count

Sum all matches found across all tower patterns

Key Takeaway

🎯 Key Insight: Convert row and column sequences into hashable patterns (tuples/strings) to enable instant O(1) lookups instead of expensive O(n) element-by-element comparisons.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 10

The optimal approach uses a two-pass hash table strategy: first pass stores all row patterns with their frequencies, second pass checks each column pattern against the stored rows. This achieves O(n²) time complexity which is much better than the brute force O(n³) approach, at the cost of O(n²) space for the hash table.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n²)	O(n²)	First pass: hash all rows; Second pass: check columns against row hashes
Brute Force (Nested Loops)	O(n³)	O(1)	Compare every row with every column element by element

Two-Pass Hash Table — Algorithm Steps

First pass: Convert each row to a string/tuple and store frequency in hash map
Second pass: Convert each column to the same format
For each column pattern, add the frequency of matching rows to result
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash All Rows

Convert each row to a pattern and store in hash table with frequency

Process Columns

Convert each column to same pattern format

Lookup Matches

Check if column pattern exists in row hash table

Count Results

Add frequency of matching row patterns to result

Code -

solution.c — C

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

// Simple hash table implementation for this problem
#define MAX_ROWS 1000

typedef struct {
    char key[1000];
    int count;
    int used;
} HashEntry;

HashEntry hashTable[MAX_ROWS];

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

int equalPairs(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    memset(hashTable, 0, sizeof(hashTable));
    
    // First pass: store all rows
    for (int i = 0; i < n; i++) {
        char rowStr[1000] = "";
        for (int k = 0; k < n; k++) {
            char temp[20];
            sprintf(temp, "%d,", grid[i][k]);
            strcat(rowStr, temp);
        }
        
        int h = hash(rowStr);
        while (hashTable[h].used && strcmp(hashTable[h].key, rowStr) != 0) {
            h = (h + 1) % MAX_ROWS;
        }
        if (!hashTable[h].used) {
            strcpy(hashTable[h].key, rowStr);
            hashTable[h].used = 1;
        }
        hashTable[h].count++;
    }
    
    // Second pass: check columns
    int result = 0;
    for (int j = 0; j < n; j++) {
        char colStr[1000] = "";
        for (int i = 0; i < n; i++) {
            char temp[20];
            sprintf(temp, "%d,", grid[i][j]);
            strcat(colStr, temp);
        }
        
        int h = hash(colStr);
        while (hashTable[h].used && strcmp(hashTable[h].key, colStr) != 0) {
            h = (h + 1) % MAX_ROWS;
        }
        if (hashTable[h].used) {
            result += hashTable[h].count;
        }
    }
    
    return result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

First pass O(n²) to hash all rows, second pass O(n²) to check all columns

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash table can store up to n row patterns, each of length n

⚠ Quadratic Space

28.4K Views

Medium Frequency

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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler