Coloring A Border

Coloring A Border - Problem

Coloring A Border is a fascinating grid traversal problem that combines graph theory with practical visualization concepts.

You're given an m x n integer matrix grid where each cell represents a colored square, and three integers: row, col, and color. Your task is to identify a connected component (a group of adjacent cells with the same color) starting from grid[row][col], find its border, and color that border with the new color.

What is a border? A cell in the connected component is part of the border if:
• It's on the edge of the grid (first/last row/column), OR
• It's adjacent to at least one cell that's NOT part of the same connected component

Goal: Return the modified grid after coloring the border of the connected component containing grid[row][col].

Input & Output

example_1.py — Basic Connected Component

$ Input: grid = [[1,1],[1,2]], row = 0, col = 0, color = 3

› Output: [[3,3],[3,2]]

💡 Note: The connected component starting at (0,0) consists of cells with value 1: (0,0), (0,1), and (1,0). All these cells are border cells because they're either on the grid boundary or adjacent to cell (1,1) which has a different color. So all three cells get colored with 3.

example_2.py — Interior vs Border Cells

$ Input: grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2

› Output: [[2,2,2],[2,1,2],[2,2,2]]

💡 Note: The entire grid forms one connected component of 1's. The center cell (1,1) is interior (surrounded by same-colored cells), while all edge cells are border cells. Only the border gets colored with 2, leaving the center cell unchanged.

example_3.py — Same Color Edge Case

$ Input: grid = [[1,1],[1,2]], row = 0, col = 0, color = 1

› Output: [[1,1],[1,2]]

💡 Note: Since the target color (1) is the same as the original color of the connected component, no changes are made to the grid.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 50
1 ≤ grid[i][j], color ≤ 1000
0 ≤ row < m
0 ≤ col < n

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a single DFS traversal with clever temporary marking. During DFS, we mark visited cells with negative values and simultaneously check if each cell is a border cell. Border cells (on grid edge or adjacent to different colors) keep their negative marking, while interior cells are restored to original color. Finally, we color all negative-marked cells with the target color. This achieves O(m×n) time complexity with minimal space overhead.

Common Approaches

✓ Brute Force (Multiple Passes)

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

This approach first identifies all cells in the connected component by checking every cell in the grid. Then, for each component cell, it examines all neighbors to determine if it's a border cell. This results in multiple redundant traversals of the grid.

Single DFS with Border Detection (Optimal)

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

This optimal approach performs component discovery and border detection simultaneously during a single DFS traversal. As we visit each cell in the component, we immediately check if it's a border cell by examining its position and neighbors. We use a temporary marker to distinguish between processed cells and original component cells.

Brute Force (Multiple Passes) — Algorithm Steps

Find all cells in the connected component using DFS/BFS from the starting cell
Store all component cells in a set for quick lookup
For each component cell, check if it's a border cell by examining all 4 neighbors
A cell is border if it's on grid edge or has a neighbor not in the component
Color all identified border cells with the new color

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS Component Discovery

First pass: Use DFS to find all cells in the connected component

Border Detection

Second pass: Check each component cell to see if it's a border cell

Color Application

Final step: Color all identified border cells

Code -

solution.c — C

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

#define MAX_CELLS 10000

typedef struct {
    int r, c;
} Cell;

int m, n, originalColor;
Cell component[MAX_CELLS];
int componentSize = 0;
bool visited[100][100];

void dfs(int** grid, int r, int c) {
    if (r < 0 || r >= m || c < 0 || c >= n || 
        grid[r][c] != originalColor || visited[r][c]) {
        return;
    }
    
    visited[r][c] = true;
    component[componentSize++] = (Cell){r, c};
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    for (int i = 0; i < 4; i++) {
        dfs(grid, r + directions[i][0], c + directions[i][1]);
    }
}

bool isInComponent(int r, int c) {
    for (int i = 0; i < componentSize; i++) {
        if (component[i].r == r && component[i].c == c) {
            return true;
        }
    }
    return false;
}

int** colorBorder(int** grid, int gridSize, int* gridColSize, int row, int col, int color, int* returnSize, int** returnColumnSizes) {
    m = gridSize;
    n = gridColSize[0];
    originalColor = grid[row][col];
    componentSize = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = false;
        }
    }
    
    if (originalColor == color) {
        *returnSize = gridSize;
        *returnColumnSizes = gridColSize;
        return grid;
    }
    
    dfs(grid, row, col);
    
    Cell borderCells[MAX_CELLS];
    int borderSize = 0;
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    for (int i = 0; i < componentSize; i++) {
        int r = component[i].r, c = component[i].c;
        bool isBorder = false;
        
        if (r == 0 || r == m - 1 || c == 0 || c == n - 1) {
            isBorder = true;
        } else {
            for (int j = 0; j < 4; j++) {
                int nr = r + directions[j][0], nc = c + directions[j][1];
                if (!isInComponent(nr, nc)) {
                    isBorder = true;
                    break;
                }
            }
        }
        
        if (isBorder) {
            borderCells[borderSize++] = (Cell){r, c};
        }
    }
    
    for (int i = 0; i < borderSize; i++) {
        grid[borderCells[i].r][borderCells[i].c] = color;
    }
    
    *returnSize = gridSize;
    *returnColumnSizes = gridColSize;
    return grid;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We traverse the grid multiple times: once for DFS (O(m×n)) and once for border detection (O(component_size × 4))

✓ Linear Growth

Space Complexity

O(m×n)

Space for recursion stack (O(m×n)) plus storage for component cells (O(component_size))

⚡ Linearithmic Space

28.5K 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 (Multiple Passes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler