Coloring A Border - Practice Coding Problems

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

Understanding the Visualization

Identify Component

Starting from the given cell, use DFS to find all connected cells with the same color

Detect Borders

A cell is a border if it's on the grid edge OR has a neighbor with different color

Apply Color

Color all identified border cells with the new color

Key Takeaway

🎯 Key Insight: Use DFS with temporary negative marking to simultaneously discover the connected component and identify border cells in a single traversal, achieving optimal O(m×n) time complexity.

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

Approach	Time	Space	Notes
✓ Single DFS with Border Detection (Optimal)	O(m×n)	O(m×n)	Combine component discovery and border detection in one DFS traversal
Brute Force (Multiple Passes)	O(m×n)	O(m×n)	Check every cell to see if it belongs to the component, then check if it's a border

Single DFS with Border Detection (Optimal) — Algorithm Steps

Start DFS from the given cell and mark it with a temporary value (negative of original)
For each cell, check if it's a border while exploring neighbors
A cell is border if it's on grid edge or has an unmarked neighbor with different color
After DFS, scan marked cells and color border cells with new color
Restore non-border cells to their original color

Visualization

Tap to expand

Step-by-Step Walkthrough

Mark and Check

During DFS, mark each cell with negative value and check if it's a border

Border Decision

Keep negative marking for border cells, restore original for interior cells

Final Coloring

Color all cells with negative values (borders) with the new color

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

void dfs(int** grid, int gridSize, int gridColSize, int r, int c, int originalColor) {
    grid[r][c] = -originalColor;
    bool isBorder = false;
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    for (int i = 0; i < 4; i++) {
        int nr = r + directions[i][0];
        int nc = c + directions[i][1];
        
        if (nr < 0 || nr >= gridSize || nc < 0 || nc >= gridColSize ||
            abs_val(grid[nr][nc]) != originalColor) {
            isBorder = true;
        } else if (grid[nr][nc] == originalColor) {
            dfs(grid, gridSize, gridColSize, nr, nc, originalColor);
        }
    }
    
    if (!isBorder) {
        grid[r][c] = originalColor;
    }
}

int** colorBorder(int** grid, int gridSize, int* gridColSize, int row, int col, int color, int* returnSize, int** returnColumnSizes) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        *returnSize = gridSize;
        *returnColumnSizes = gridColSize;
        return grid;
    }
    
    int originalColor = grid[row][col];
    
    if (originalColor == color) {
        *returnSize = gridSize;
        *returnColumnSizes = gridColSize;
        return grid;
    }
    
    dfs(grid, gridSize, gridColSize[0], row, col, originalColor);
    
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[0]; j++) {
            if (grid[i][j] < 0) {
                grid[i][j] = color;
            }
        }
    }
    
    *returnSize = gridSize;
    *returnColumnSizes = gridColSize;
    return grid;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Single DFS traversal visits each cell in component exactly once, plus one final scan of marked cells

✓ Linear Growth

Space Complexity

O(m×n)

Recursion stack space in worst case when entire grid forms one component

⚡ 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

Single DFS with Border Detection (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler