Minimum Number of Operations to Satisfy Conditions

Minimum Number of Operations to Satisfy Conditions - Problem

You are given a 2D matrix grid of size m × n. Your task is to transform this grid using the minimum number of operations to satisfy two critical conditions:

Vertical Consistency: Each cell must be equal to the cell directly below it (if it exists)
Horizontal Variation: Each cell must be different from the cell to its right (if it exists)

In one operation, you can change any cell to any non-negative integer. The challenge is to find the minimum number of operations needed to make the entire grid satisfy both conditions simultaneously.

Think of this as creating columns of identical values where adjacent columns must have different values - like organizing a colorful striped pattern!

Input & Output

example_1.py — Basic Grid

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

› Output: 0

💡 Note: The grid already satisfies both conditions: each column has identical values (vertical consistency) and adjacent columns have different values (1≠0, 0≠2). No operations needed.

example_2.py — Mixed Grid

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

› Output: 3

💡 Note: Adjacent columns have the same values, violating horizontal variation. We need to change one entire column (2 cells) plus 1 cell in another column to make adjacent columns different. Optimal: change middle column to value 2, requiring 2 operations.

example_3.py — Single Column

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

› Output: 2

💡 Note: Single column needs vertical consistency - all cells must have the same value. We can change 2 cells to match the third cell, requiring 2 operations total.

Constraints

1 ≤ m, n ≤ 1000
0 ≤ grid[i][j] ≤ 9
Memory limit: 256 MB
Time limit: 2 seconds

Visualization

Tap to expand

Understanding the Visualization

Analyze Each Column

Calculate the cost to make each column any color from 0-9

Apply DP Logic

For each column, choose the color that minimizes total operations while differing from the previous column

Optimize Space

Only keep track of the previous column's DP state to minimize memory usage

Find Minimum

Return the minimum cost across all possible colors for the last column

Key Takeaway

🎯 Key Insight: Use Dynamic Programming to optimize column by column, ensuring adjacent columns have different colors while minimizing the total number of cell changes needed.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses Dynamic Programming to build the answer column by column. For each column, we calculate the cost of making it each possible color (0-9), then use DP to find the minimum operations needed while ensuring adjacent columns have different colors. The space-optimized DP approach achieves O(m×n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m × n)	O(1)	Build optimal solution column by column using dynamic programming

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table: dp[col][color] = min operations for columns 0..col with col having color
For each column, calculate cost of making it each possible color (0-9)
For each color choice, add cost to minimum of previous column's different colors
Use space optimization to only keep current and previous column states
Return minimum value from the last column across all colors

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize First Column

Calculate cost to make first column each possible color

Process Next Column

For each color, find minimum cost from different previous colors

State Transition

dp[col][color] = min(dp[col-1][other_colors]) + cost[col][color]

Find Minimum

Return minimum value from the last column

Code -

solution.c — C

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

int getCost(int** grid, int m, int col, int color) {
    int cost = 0;
    for (int row = 0; row < m; row++) {
        if (grid[row][col] != color) cost++;
    }
    return cost;
}

int minimumOperations(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int m = gridSize, n = gridColSize[0];
    int prevDp[10];
    
    // Initialize first column
    for (int color = 0; color < 10; color++) {
        prevDp[color] = getCost(grid, m, 0, color);
    }
    
    // Process remaining columns
    for (int col = 1; col < n; col++) {
        int currDp[10];
        for (int i = 0; i < 10; i++) {
            currDp[i] = INT_MAX;
        }
        
        for (int currColor = 0; currColor < 10; currColor++) {
            int cost = getCost(grid, m, col, currColor);
            
            for (int prevColor = 0; prevColor < 10; prevColor++) {
                if (prevColor != currColor) {
                    if (prevDp[prevColor] + cost < currDp[currColor]) {
                        currDp[currColor] = prevDp[prevColor] + cost;
                    }
                }
            }
        }
        
        for (int i = 0; i < 10; i++) {
            prevDp[i] = currDp[i];
        }
    }
    
    int result = prevDp[0];
    for (int i = 1; i < 10; i++) {
        if (prevDp[i] < result) {
            result = prevDp[i];
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We process each cell once to calculate costs, then O(n) DP with constant color choices

✓ Linear Growth

Space Complexity

O(1)

Using space-optimized DP with only two arrays of size 10 for previous and current states

✓ Linear Space

68.0K Views

High Frequency

~25 min Avg. Time

1.9K 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler