Minimum Operations to Write the Letter Y on a Grid

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

You are given a 0-indexed n × n grid where n is odd, and grid[r][c] is 0, 1, or 2.

We say that a cell belongs to the Letter Y if it belongs to one of the following:

The diagonal starting at the top-left cell and ending at the center cell of the grid
The diagonal starting at the top-right cell and ending at the center cell of the grid
The vertical line starting at the center cell and ending at the bottom border of the grid

The Letter Y is written on the grid if and only if:

All values at cells belonging to the Y are equal
All values at cells not belonging to the Y are equal
The values at cells belonging to the Y are different from the values at cells not belonging to the Y

Return the minimum number of operations needed to write the letter Y on the grid given that in one operation you can change the value at any cell to 0, 1, or 2.

Input & Output

Example 1 — Basic 3x3 Grid

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

› Output: 3

💡 Note: Y cells are at positions (0,0), (0,2), (1,1), (2,1). To minimize operations, set Y=1 and non-Y=0. Need to change 3 non-Y cells: (0,1) from 2→0, (1,0) from 1→0, (1,2) from 0→0 (no change), (2,0) from 0→0, (2,2) from 0→0. Actually need to change (0,1) and (1,0) and (1,2), total 3 operations.

Example 2 — Uniform Values

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

› Output: 6

💡 Note: Y cells: (0,0)=2, (0,2)=0, (1,1)=0, (2,1)=1. Non-Y cells: (0,1)=1, (1,0)=1, (1,2)=1, (2,0)=0, (2,2)=2. Best assignment requires changing most cells to achieve uniform regions.

Example 3 — Already Optimal

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

› Output: 1

💡 Note: Y cells: (0,0)=0, (0,2)=0, (1,1)=0, (2,1)=0. Non-Y: (0,1)=1, (1,0)=1, (1,2)=1, (2,0)=1, (2,2)=1. Y=0, Non-Y=1 is already mostly correct, need only 1 change.

Constraints

n == grid.length == grid[i].length
3 ≤ n ≤ 49
n is odd
grid[i][j] is either 0, 1, or 2

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8 a Amazon 6

The key insight is that we only have 3 possible values (0,1,2) and need Y cells to have one value while non-Y cells have a different value. We can try all 6 valid combinations (Y_val ≠ non_Y_val) and count operations for each. Best approach uses frequency counting to optimize the calculation. Time: O(n²), Space: O(1).

Common Approaches

✓ Frequency Counting Optimization

⏱️ Time: O(n²) Space: O(1)

Instead of trying all combinations blindly, count how many cells of each value (0,1,2) are in Y region vs non-Y region. Then for each valid assignment, calculate operations as total_cells - max_frequency.

Try All Color Combinations

⏱️ Time: O(n²) Space: O(n²)

Since we only have 3 possible values (0, 1, 2), we can try all combinations where Y cells have one value and non-Y cells have a different value. For each combination, count the operations needed.

Frequency Counting Optimization — Algorithm Steps

Step 1: Identify Y cells and separate the grid into Y and non-Y regions
Step 2: Count frequency of each value (0,1,2) in both regions
Step 3: For each valid (Y_value, non_Y_value) pair, calculate operations needed using frequency counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Track how many 0s, 1s, 2s in Y vs non-Y regions

Calculate Operations

For each combo: ops = total - already_correct

Find Minimum

Choose the assignment requiring fewest changes

Code -

solution.c — C

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

int solution(int** grid, int n) {
    int center = n / 2;
    
    // Count frequencies in Y and non-Y regions
    int yCount[3] = {0, 0, 0};  // count of 0,1,2 in Y region
    int nonYCount[3] = {0, 0, 0};  // count of 0,1,2 in non-Y region
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // Check if cell belongs to Y
            int isYCell = 0;
            
            // Top-left to center diagonal: i == j and i <= center
            if (i == j && i <= center) {
                isYCell = 1;
            }
            // Top-right to center diagonal: i + j == n-1 and i <= center
            else if (i + j == n - 1 && i <= center) {
                isYCell = 1;
            }
            // Center to bottom vertical line: j == center and i >= center
            else if (j == center && i >= center) {
                isYCell = 1;
            }
            
            if (isYCell) {
                yCount[grid[i][j]]++;
            } else {
                nonYCount[grid[i][j]]++;
            }
        }
    }
    
    int minOps = INT_MAX;
    
    // Try all valid combinations
    for (int yVal = 0; yVal < 3; yVal++) {
        for (int nonYVal = 0; nonYVal < 3; nonYVal++) {
            if (yVal == nonYVal) continue;
            
            // Operations = total_y_cells - y_cells_already_correct + total_non_y_cells - non_y_cells_already_correct
            int yTotal = yCount[0] + yCount[1] + yCount[2];
            int nonYTotal = nonYCount[0] + nonYCount[1] + nonYCount[2];
            
            int ops = (yTotal - yCount[yVal]) + (nonYTotal - nonYCount[nonYVal]);
            if (ops < minOps) {
                minOps = ops;
            }
        }
    }
    
    return minOps;
}

int main() {
    // Simple parsing for this problem - assume small grid
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Count dimensions
    int n = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && line[i+1] != '[') n++;
    }
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Simple parsing - extract numbers
    int nums[100], numCount = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] >= '0' && line[i] <= '2') {
            nums[numCount++] = line[i] - '0';
        }
    }
    
    int idx = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            grid[i][j] = nums[idx++];
        }
    }
    
    int result = solution(grid, n);
    printf("%d\n", result);
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass to identify Y cells and count frequencies O(n²), then 6 constant operations to find minimum

⚠ Quadratic Growth

Space Complexity

O(1)

Only store frequency counts for 3 values in 2 regions, which is constant space

⚠ Quadratic Space

9.0K Views

Medium Frequency

~15 min Avg. Time

234 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

Frequency Counting Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler