First Completely Painted Row or Column

First Completely Painted Row or Column - Problem

You are given a 0-indexed integer array arr, and an m x n integer matrix mat. Both arr and mat contain all the integers in the range [1, m * n].

Go through each index i in arr starting from index 0 and paint the cell in mat containing the integer arr[i].

Return the smallest index i at which either a row or a column will be completely painted in mat.

Input & Output

Example 1 — Basic Case

$ Input: arr = [1,3,4,2], mat = [[1,4],[2,3]]

› Output: 2

💡 Note: Paint cells in order: (0,0)→1, (1,1)→3, (0,1)→4. After painting 4, row 0 is complete: [1,4]. Return index 2.

Example 2 — Column Completion

$ Input: arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]

› Output: 3

💡 Note: Paint: (0,1)→2, (2,0)→8, (2,1)→7, (1,1)→4. After painting 4, column 1 is complete: [2,4,7]. Return index 3.

Example 3 — Single Row

$ Input: arr = [5,1,3], mat = [[1,3,5]]

› Output: 2

💡 Note: Paint: (0,2)→5, (0,0)→1, (0,1)→3. After painting 3, the entire row is complete. Return index 2.

Constraints

m == mat.length
n == mat[i].length
arr.length == m * n
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
1 ≤ arr[i], mat[r][c] ≤ m * n
All the integers of arr are unique
All the integers of mat are unique

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to use counters to track painted cells per row and column instead of checking completion from scratch each time. The optimal approach maintains row_count and col_count arrays, incrementing them as we paint cells. When any counter equals the row/column size, we've found our answer. Time: O(m×n), Space: O(m×n).

Common Approaches

✓ Brute Force

⏱️ Time: O(m × n × (m + n)) Space: O(m × n)

For each element in arr, find its position in mat, mark it as painted, then check every row and column to see if any is completely painted. This approach recalculates completion status from scratch each time.

Optimized with Counters

⏱️ Time: O(m × n) Space: O(m × n)

Instead of checking all rows and columns after each paint, maintain counters for painted cells in each row and column. When a counter reaches the row/column size, we know it's complete. This eliminates redundant checking.

Brute Force — Algorithm Steps

Step 1: For each arr[i], find its position in mat
Step 2: Mark that cell as painted
Step 3: Check all rows and columns for complete painting
Step 4: Return index when first complete row/column found

Visualization

Tap to expand

Step-by-Step Walkthrough

Paint Cell

Mark the cell corresponding to arr[i] as painted

Check All Rows

Scan every row to see if completely painted

Check All Columns

Scan every column to see if completely painted

Return Index

Return current index when first complete row/column found

Code -

solution.c — C

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

int solution(int* arr, int arrSize, int** mat, int matSize, int* matColSize) {
    int m = matSize, n = matColSize[0];
    
    // Create position map (using array indexing)
    int* posR = (int*)malloc((m * n + 1) * sizeof(int));
    int* posC = (int*)malloc((m * n + 1) * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            posR[mat[i][j]] = i;
            posC[mat[i][j]] = j;
        }
    }
    
    // Track painted cells
    int** painted = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        painted[i] = (int*)calloc(n, sizeof(int));
    }
    
    for (int idx = 0; idx < arrSize; idx++) {
        // Paint the cell
        int r = posR[arr[idx]];
        int c = posC[arr[idx]];
        painted[r][c] = 1;
        
        // Check if any row is complete
        for (int i = 0; i < m; i++) {
            int complete = 1;
            for (int j = 0; j < n; j++) {
                if (!painted[i][j]) {
                    complete = 0;
                    break;
                }
            }
            if (complete) {
                free(posR); free(posC);
                for (int k = 0; k < m; k++) free(painted[k]);
                free(painted);
                return idx;
            }
        }
        
        // Check if any column is complete
        for (int j = 0; j < n; j++) {
            int complete = 1;
            for (int i = 0; i < m; i++) {
                if (!painted[i][j]) {
                    complete = 0;
                    break;
                }
            }
            if (complete) {
                free(posR); free(posC);
                for (int k = 0; k < m; k++) free(painted[k]);
                free(painted);
                return idx;
            }
        }
    }
    
    free(posR); free(posC);
    for (int i = 0; i < m; i++) free(painted[i]);
    free(painted);
    return arrSize - 1;
}

int parseArray(char* line, int* arr) {
    int size = 0;
    char* p = line;
    
    // Find the opening bracket
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip [
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == '\t' || *p == '\n')) p++;
        
        if (*p && *p != ']' && (isdigit(*p) || (*p == '-' && isdigit(*(p+1))))) {
            arr[size++] = atoi(p);
            // Skip the number
            if (*p == '-') p++;
            while (*p && isdigit(*p)) p++;
        } else if (*p && *p != ']') {
            p++;
        }
    }
    return size;
}

int parseMatrix(char* line, int*** mat, int** matColSize) {
    int rows = 0;
    
    // Count rows by counting inner [ brackets
    char* temp = line;
    int in_outer = 0;
    while (*temp) {
        if (*temp == '[' && !in_outer) {
            in_outer = 1;
        } else if (*temp == '[' && in_outer) {
            rows++;
        }
        temp++;
    }
    
    if (rows == 0) return 0;
    
    *mat = (int**)malloc(rows * sizeof(int*));
    *matColSize = (int*)malloc(rows * sizeof(int));
    
    char* p = line;
    // Find first [
    while (*p && *p != '[') p++;
    if (!*p) return 0;
    p++; // skip outer [
    
    int row = 0;
    while (*p && row < rows) {
        // Find start of inner array
        while (*p && *p != '[') p++;
        if (!*p) break;
        p++; // skip inner [
        
        // Count elements in this row
        char* start = p;
        int cols = 0;
        while (*p && *p != ']') {
            // Skip whitespace and commas
            while (*p && (*p == ' ' || *p == ',' || *p == '\t')) p++;
            
            if (*p && *p != ']' && (isdigit(*p) || (*p == '-' && isdigit(*(p+1))))) {
                cols++;
                // Skip the number
                if (*p == '-') p++;
                while (*p && isdigit(*p)) p++;
            } else if (*p && *p != ']') {
                p++;
            }
        }
        
        // Allocate and parse the row
        (*mat)[row] = (int*)malloc(cols * sizeof(int));
        (*matColSize)[row] = cols;
        
        // Go back and parse numbers
        p = start;
        int col = 0;
        while (*p && *p != ']' && col < cols) {
            // Skip whitespace and commas
            while (*p && (*p == ' ' || *p == ',' || *p == '\t')) p++;
            
            if (*p && *p != ']' && (isdigit(*p) || (*p == '-' && isdigit(*(p+1))))) {
                (*mat)[row][col++] = atoi(p);
                // Skip the number
                if (*p == '-') p++;
                while (*p && isdigit(*p)) p++;
            } else if (*p && *p != ']') {
                p++;
            }
        }
        
        // Skip to end of this row
        while (*p && *p != ']') p++;
        if (*p) p++; // skip ]
        
        row++;
    }
    
    return rows;
}

int main() {
    char line1[200000], line2[200000];
    if (!fgets(line1, sizeof(line1), stdin)) return 1;
    if (!fgets(line2, sizeof(line2), stdin)) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    // Parse array
    int arr[100000];
    int arrSize = parseArray(line1, arr);
    
    // Parse matrix
    int** mat;
    int* matColSize;
    int matSize = parseMatrix(line2, &mat, &matColSize);
    
    printf("%d\n", solution(arr, arrSize, mat, matSize, matColSize));
    
    // Cleanup
    for (int i = 0; i < matSize; i++) free(mat[i]);
    free(mat);
    free(matColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × (m + n))

For each of m×n elements, we check m rows + n columns

✓ Linear Growth

Space Complexity

O(m × n)

Boolean matrix to track painted cells plus position lookup

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~15 min Avg. Time

945 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler