Minimum Number of Operations to Satisfy Conditions - Problem

You are given a 2D matrix grid of size m x n. In one operation, you can change the value of any cell to any non-negative number.

You need to perform some operations such that each cell grid[i][j] is:

Equal to the cell below it, i.e. grid[i][j] == grid[i + 1][j] (if it exists)
Different from the cell to its right, i.e. grid[i][j] != grid[i][j + 1] (if it exists)

Return the minimum number of operations needed.

Input & Output

Example 1 — Basic 3x3 Grid

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

› Output: 3

💡 Note: Make column 0 all 1s (cost 0), column 1 all 0s (cost 1), column 2 all 1s (cost 2). Total: 3 operations.

Example 2 — Already Valid

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

› Output: 0

💡 Note: Each column has uniform values and adjacent columns differ. No operations needed.

Example 3 — Single Row

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

› Output: 4

💡 Note: Change to [0,1,0,1] - each column uniform, adjacent differ. Cost: 1+1+1+1 = 4.

Constraints

1 ≤ m, n ≤ 1000
0 ≤ grid[i][j] ≤ 9

Visualization

Tap to expand

Asked in

G Google 42 f Meta 35 a Amazon 28

The key insight is that each column must have uniform values and adjacent columns must differ. We can limit values to {0,1,2} and use dynamic programming with frequency counting. Count frequency of each value per column, then use DP where dp[col][val] represents minimum operations for columns 0 to col with column col having value val. Best approach: DP with frequency optimization. Time: O(m×n), Space: O(n).

Common Approaches

✓ Brute Force with Recursion

⏱️ Time: O(3^n) Space: O(n)

For each column, try assigning values 0, 1, or 2 to make all cells in that column equal. Use recursion to explore all combinations while ensuring adjacent columns have different values.

Dynamic Programming with Frequency Count

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

For each column, count frequency of each value (0, 1, 2). Use dynamic programming where dp[col][value] represents minimum operations to make columns 0 to col valid, with column col having the given value.

Brute Force with Recursion — Algorithm Steps

For each column, try values 0, 1, 2
Calculate cost to make entire column that value
Recursively solve remaining columns with constraint
Return minimum cost across all choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Column 0

Try values 0, 1, 2 and calculate cost

Column 1

Try values different from column 0

Result

Find minimum total cost

Code -

solution.c — C

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

static int grid[1000][1000];
static int m, n;

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

int backtrack(int col, int prevValue) {
    if (col == n) return 0;
    
    int minOps = INT_MAX;
    for (int value = 0; value < 10; value++) {  // Consider all values 0-9
        if (value != prevValue) {
            int cost = getCost(col, value);
            int remaining = backtrack(col + 1, value);
            if (cost + remaining < minOps) {
                minOps = cost + remaining;
            }
        }
    }
    
    return minOps;
}

int solution() {
    if (m == 0 || n == 0) return 0;
    return backtrack(0, -1);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for 2D array
    char *ptr = line + 1; // Skip first '['
    m = 0;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++; // Skip '['
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[m][n] = strtol(ptr, &ptr, 10);
                    n++;
                } else {
                    ptr++;
                }
            }
            if (*ptr == ']') ptr++;
            m++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each of n columns, we try 3 possible values recursively

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is n columns

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 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

Minimum Number of Operations to Satisfy Conditions - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler