Equal Row and Column Pairs

Equal Row and Column Pairs - Problem

Given a 0-indexed n x n integer matrix grid, return the number of pairs (ri, cj) such that row ri and column cj are equal.

A row and column pair is considered equal if they contain the same elements in the same order (i.e., an equal array).

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: We check all row-column pairs: Row 0 [3,2,1] vs Columns [3,1,5], [2,7,7], [1,1,1] - no matches. Row 1 [1,7,1] vs Columns - no matches. Row 2 [5,7,1] vs Columns - no matches. Total: 0 pairs.

Example 2 — Multiple Matches

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

› Output: 3

💡 Note: After checking all row-column pairs systematically, we find 3 pairs where the row pattern exactly matches the column pattern.

Example 3 — Single Element

$ Input: grid = [[5]]

› Output: 1

💡 Note: Only one row [5] and one column [5], they are equal, so 1 pair.

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 200
1 ≤ grid[i][j] ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12

The key insight is to convert each row and column to a comparable format (string) and use frequency counting. The optimal approach uses hash maps to count pattern frequencies, then multiplies row count by column count for each matching pattern. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force Comparison

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

For each row, compare it with every column by checking if all corresponding elements are equal. This involves nested loops to iterate through all row-column pairs.

Hash Map with Frequency Count

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

Convert each row and column to a string representation, then use a hash map to count how many times each pattern appears. Multiply row count by column count for each pattern.

Brute Force Comparison — Algorithm Steps

Iterate through each row
For each row, iterate through each column
Compare elements one by one
Count matching pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Row

Pick a row to compare

Compare with Columns

Check each column element by element

Count Matches

Increment count when row equals column

Code -

solution.c — C

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

static int result[1000][100];
static int result_sizes[1000];
static int result_count = 0;
static int current[100];
static int current_size = 0;

void backtrack(int num, int start) {
    // If we have at least 2 factors and num becomes 1, we found a valid combination
    if (num == 1) {
        if (current_size > 1) {
            for (int i = 0; i < current_size; i++) {
                result[result_count][i] = current[i];
            }
            result_sizes[result_count] = current_size;
            result_count++;
        }
        return;
    }
    
    // Try all possible factors from start up to sqrt(num)
    int sqrt_num = (int)sqrt(num) + 1;
    for (int i = start; i <= sqrt_num; i++) {
        if (num % i == 0) {
            current[current_size++] = i;
            backtrack(num / i, i);
            current_size--;
        }
    }
    
    // Also try num itself as the last factor (if num >= start and we have at least 1 factor already)
    if (num >= start && current_size > 0) {
        current[current_size++] = num;
        backtrack(1, num);
        current_size--;
    }
}

void solution(int n) {
    result_count = 0;
    current_size = 0;
    
    if (n <= 1) {
        printf("[]\n");
        return;
    }
    
    backtrack(n, 2);
    
    printf("[");
    for (int i = 0; i < result_count; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < result_sizes[i]; j++) {
            if (j > 0) printf(",");
            printf("%d", result[i][j]);
        }
        printf("]");
    }
    printf("]\n");
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Extract the first number from the matrix for factorization
    char* ptr = line;
    while (*ptr && (*ptr < '0' || *ptr > '9')) ptr++; // Find first digit
    
    int n = 0;
    if (*ptr) {
        n = strtol(ptr, NULL, 10);
    }
    
    solution(n);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: n rows × n columns × n elements per comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for counting, no extra data structures

✓ Linear Space

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

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler