First Completely Painted Row or Column - Practice Coding Problems

First Completely Painted Row or Column - Problem

Imagine you're playing a unique painting game! You have a grid (matrix) filled with numbers from 1 to m×n, and an instruction array that tells you which numbers to paint in order.

Your task is to follow the painting instructions one by one. For each number in the instruction array, find that number in the grid and paint it. The moment you complete painting an entire row or an entire column, you win!

Goal: Find the smallest index in the instruction array at which you'll have your first complete row or column painted.

Input: An integer array arr (painting instructions) and an m×n matrix mat containing all numbers 1 to m×n exactly once.

Output: The index i where painting arr[i] completes the first full row or column.

Input & Output

example_1.py — Basic Example

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

› Output: 2

💡 Note: We paint in order: 1→(0,0), 3→(0,2), then 4→(1,0). After painting 4, column 0 is complete with cells (0,0) and (1,0) both painted. This happens at index 2.

example_2.py — Row 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 order: 2→(0,1), 8→(2,0), 7→(2,1), 4→(1,1). After painting 4, we need to check what's complete. The answer is at index 3.

example_3.py — Single Row Matrix

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

› Output: 1

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

Constraints

m == mat.length
n == mat[i].length
arr.length == m * n
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
All values in arr are distinct and in range [1, m * n]
All values in mat are distinct and in range [1, m * n]

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Create a map showing where each number is located and initialize counters for each row and column

Paint Strategically

For each instruction, instantly find the cell location and paint it

Track Progress

Decrement the counters for the affected row and column

Declare Victory

The moment any counter hits zero, you've completed a line and won!

Key Takeaway

🎯 Key Insight: Instead of repeatedly checking all rows and columns, maintain counters that instantly tell us when a line is complete. This transforms an O(k×m×n) problem into an elegant O(m×n) solution!

Asked in

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

The optimal solution uses a hash map for position lookup combined with row/column completion counters. Instead of checking all cells repeatedly, we track how many unpainted cells remain in each row and column. When any counter reaches zero, we've found our answer in O(m×n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Rows/Columns)	O(k * m * n)	O(m * n)	After painting each cell, check all rows and columns for completion
One-Pass Optimal Solution	O(m * n)	O(m * n)	Build position map and track completion simultaneously in one pass
Two-Pass with Counter Tracking	O(m * n)	O(m * n)	Build position map first, then track row/column completion counters

Brute Force (Check All Rows/Columns) — Algorithm Steps

Create a boolean matrix to track painted cells
For each instruction in the array:
Find the number's position in the matrix
Mark that position as painted
Check all rows to see if any is completely painted
Check all columns to see if any is completely painted
If found complete row/column, return current index

Visualization

Tap to expand

Step-by-Step Walkthrough

Paint Cell

Mark the current number's position as painted

Check All Rows

Scan through every row to see if any is completely painted

Check All Columns

Scan through every column to see if any is completely painted

Repeat

Move to next instruction and repeat the process

Code -

solution.c — C

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

typedef struct {
    int row, col;
} Position;

int firstCompleteIndex(int* arr, int arrSize, int** mat, int matSize, int* matColSize) {
    int m = matSize, n = matColSize[0];
    bool** painted = malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        painted[i] = calloc(n, sizeof(bool));
    }
    
    // Create position array (assuming values 1 to m*n)
    Position* pos = malloc((m * n + 1) * sizeof(Position));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            pos[mat[i][j]].row = i;
            pos[mat[i][j]].col = j;
        }
    }
    
    for (int idx = 0; idx < arrSize; idx++) {
        int row = pos[arr[idx]].row;
        int col = pos[arr[idx]].col;
        painted[row][col] = true;
        
        // Check row completion
        bool rowComplete = true;
        for (int j = 0; j < n; j++) {
            if (!painted[row][j]) {
                rowComplete = false;
                break;
            }
        }
        if (rowComplete) {
            // Cleanup
            for (int i = 0; i < m; i++) free(painted[i]);
            free(painted);
            free(pos);
            return idx;
        }
        
        // Check column completion
        bool colComplete = true;
        for (int i = 0; i < m; i++) {
            if (!painted[i][col]) {
                colComplete = false;
                break;
            }
        }
        if (colComplete) {
            // Cleanup
            for (int i = 0; i < m; i++) free(painted[i]);
            free(painted);
            free(pos);
            return idx;
        }
    }
    
    // Cleanup
    for (int i = 0; i < m; i++) free(painted[i]);
    free(painted);
    free(pos);
    return -1;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * m * n)

For each of k instructions, we check all m*n cells to verify row/column completion

✓ Linear Growth

Space Complexity

O(m * n)

Need a boolean matrix to track which cells are painted

⚡ Linearithmic Space

28.3K Views

Medium Frequency

~15 min Avg. Time

847 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 Rows/Columns) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler