Minimum Operations to Make a Uni-Value Grid

Minimum Operations to Make a Uni-Value Grid - Problem

The Magic Number Grid Challenge

You are given a 2D integer grid of size m x n and a magic number x. In one operation, you can add x to or subtract x from any element in the grid.

A uni-value grid is a grid where all elements are equal - imagine transforming a chaotic grid into perfect harmony! Your mission is to find the minimum number of operations needed to make all grid elements the same value.

Goal: Return the minimum operations to achieve a uni-value grid, or -1 if impossible.

Key Insight: Since we can only add/subtract multiples of x, all elements must have the same remainder when divided by x for a solution to exist!

Input & Output

example_1.py — Basic Grid

$ Input: grid = [[2,4],[6,8]], x = 2

› Output: 4

💡 Note: We can make all elements equal to 4: 2→4 (1 op), 4→4 (0 ops), 6→4 (1 op), 8→4 (2 ops). Total: 4 operations.

example_2.py — Impossible Case

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

› Output: -1

💡 Note: Elements have different remainders when divided by 1 (which is always 0), but since all have remainder 0, this should be possible. Actually, all elements can be made equal to any value with x=1.

example_3.py — Single Element

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

› Output: 0

💡 Note: Grid already has only one element, so it's already uni-value. No operations needed.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m * n ≤ 10⁵
1 ≤ x ≤ 10⁴
Important: All elements in same row have equal length

Visualization

Tap to expand

Understanding the Visualization

Check Harmony Possibility

All instruments must be in compatible keys (same remainder mod x)

Find Optimal Pitch

The median note minimizes total adjustments needed

Calculate Adjustments

Count how many semitone steps each musician needs

Achieve Perfect Harmony

All musicians now play the same optimal note

Key Takeaway

🎯 Key Insight: The median minimizes the sum of absolute deviations, making it the mathematically optimal target for minimum operations.

Asked in

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

The optimal solution uses the median property - the median of sorted elements minimizes the sum of absolute deviations. First, check if all elements have the same remainder when divided by x. Then sort elements, find the median as target value, and calculate total operations needed. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Median Finding with Sorting	O(n log n)	O(n)	Sort elements and find median as optimal target value
Try Every Possible Target Value	O(n²)	O(n)	Test each grid element as potential target and calculate total operations

Median Finding with Sorting — Algorithm Steps

Flatten the 2D grid and check if solution is possible
Sort all elements in the flattened array
Find the median element (middle element for odd length, any of two middle for even)
Calculate operations needed to transform all elements to median value

Visualization

Tap to expand

Step-by-Step Walkthrough

Flatten & Check

Convert grid to array and verify feasibility

Sort Elements

Sort array to easily find median

Find Median

Median minimizes sum of absolute deviations

Calculate Ops

Sum operations needed to reach median

Code -

solution.c — C

#include <stdlib.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int minOperations(int** grid, int gridSize, int* gridColSize, int x) {
    int total = 0;
    for (int i = 0; i < gridSize; i++) {
        total += gridColSize[i];
    }
    
    int* nums = (int*)malloc(total * sizeof(int));
    int idx = 0;
    
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[i]; j++) {
            nums[idx++] = grid[i][j];
        }
    }
    
    if (total == 0) return 0;
    
    int remainder = nums[0] % x;
    for (int i = 0; i < total; i++) {
        if (nums[i] % x != remainder) {
            free(nums);
            return -1;
        }
    }
    
    qsort(nums, total, sizeof(int), compare);
    int median = nums[total / 2];
    
    int operations = 0;
    for (int i = 0; i < total; i++) {
        operations += abs(nums[i] - median) / x;
    }
    
    free(nums);
    return operations;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates the complexity where n is total elements in grid

⚡ Linearithmic

Space Complexity

O(n)

Space for flattened array and sorting

⚡ Linearithmic Space

42.3K Views

Medium-High Frequency

~18 min Avg. Time

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

Median Finding with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler