Minimum Operations to Write the Letter Y on a Grid

Minimum Operations to Write the Letter Y on a Grid - Problem

Imagine you have a square grid of cells where each cell contains one of three values: 0, 1, or 2. Your mission is to transform this grid so that it displays a perfect Letter Y pattern!

The Letter Y consists of three parts:

🔸 Left diagonal: from top-left corner to the center
🔸 Right diagonal: from top-right corner to the center
🔸 Vertical line: from center to the bottom edge

For the grid to display a valid Letter Y, you need:

All cells belonging to the Y must have the same value
All cells NOT belonging to the Y must have the same value
The Y cells and non-Y cells must have different values

In one operation, you can change any cell to any value (0, 1, or 2). Find the minimum operations needed to create a perfect Letter Y!

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: grid = [[1,2,2],[1,1,0],[0,1,0]]

› Output: 3

💡 Note: We can change grid[0][1] to 1, grid[1][2] to 1, and grid[2][2] to 1. The Y pattern will have value 1, and the background will have value 0.

example_2.py — All Same Values

$ Input: grid = [[2,1,0],[1,1,1],[0,1,0]]

› Output: 4

💡 Note: The center and bottom cells of Y already have value 1. We need to change 2 diagonal cells to 1, and 2 background cells to a different value (like 0).

example_3.py — Larger 5x5 Grid

$ Input: grid = [[0,1,1,1,0],[2,1,0,1,2],[2,2,2,2,2],[2,1,2,1,2],[2,1,2,1,2]]

› Output: 12

💡 Note: The Y pattern consists of 9 cells total. We need to find the optimal assignment that minimizes total changes across all 25 cells.

Constraints

n == grid.length == grid[r].length
3 ≤ n ≤ 49
n is odd
0 ≤ grid[r][c] ≤ 2

Visualization

Tap to expand

Understanding the Visualization

Identify Y Pattern

Mark the diagonal lines and vertical stem of the Y

Count Current Colors

Analyze what colors are currently in Y vs background

Find Best Assignment

Choose colors that minimize tile replacements

Calculate Operations

Count how many tiles need to be changed

Key Takeaway

🎯 Key Insight: With only 3 possible values, we can efficiently try all valid color combinations and choose the one requiring minimum changes by counting frequencies rather than explicitly trying each combination.

Asked in

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

The optimal approach uses frequency counting to track value distributions in Y-cells vs non-Y cells. By trying each possible Y-value and finding the best complementary background value, we can calculate the minimum operations in O(n²) time with a single grid traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n²)	O(1)	Try all possible color combinations for Y and non-Y cells
Optimized Counting (One Pass)	O(n²)	O(1)	Count frequencies of Y and non-Y cells in one pass, then calculate optimal assignment

Brute Force (Try All Combinations) — Algorithm Steps

Identify all cells that belong to the Letter Y pattern
For each valid combination (Y_color, non_Y_color) where Y_color ≠ non_Y_color:
Count operations needed: cells in Y that aren't Y_color + cells not in Y that aren't non_Y_color
Return the minimum operations across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Y Pattern

Mark all cells that belong to the Letter Y

Try Combination

Test each valid color combination

Count Operations

Count cells that need to change for this combination

Find Minimum

Keep track of the combination requiring fewest operations

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

int isYCell(int r, int c, int n) {
    int center = n / 2;
    return (r == c && r <= center) ||
           (r + c == n - 1 && r <= center) ||
           (c == center && r >= center);
}

int minimumOperationsToWriteY(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    int minOps = INT_MAX;
    
    for (int yVal = 0; yVal < 3; yVal++) {
        for (int nonYVal = 0; nonYVal < 3; nonYVal++) {
            if (yVal == nonYVal) continue;
            
            int ops = 0;
            for (int r = 0; r < n; r++) {
                for (int c = 0; c < n; c++) {
                    if (isYCell(r, c, n)) {
                        if (grid[r][c] != yVal) ops++;
                    } else {
                        if (grid[r][c] != nonYVal) ops++;
                    }
                }
            }
            if (ops < minOps) {
                minOps = ops;
            }
        }
    }
    
    return minOps;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We iterate through the n×n grid a constant number of times (6 combinations)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts and minimum operations

✓ Linear Space

28.4K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler