Minimum Operations to Make a Uni-Value Grid

Minimum Operations to Make a Uni-Value Grid - Problem

You are given a 2D integer grid of size m x n and an integer 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 the elements of it are equal.

Return the minimum number of operations to make the grid uni-value. If it is not possible, return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: All elements have remainder 0 when divided by 2. Using median 4 as target: |2-4|/2 + |4-4|/2 + |6-4|/2 + |8-4|/2 = 1 + 0 + 1 + 2 = 4 operations

Example 2 — Impossible Case

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

› Output: -1

💡 Note: Elements have different remainders when divided by 2: 1%2=1, 5%2=1, 2%2=0, 3%2=1. Since not all elements have the same remainder, it's impossible to make them all equal.

Example 3 — Single Element

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

› Output: 0

💡 Note: Grid already has single value, 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 ≤ grid[i][j], x ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The key insight is that all elements must have the same remainder when divided by x to be transformable to a common value. The optimal target is the median of all values, which minimizes the sum of absolute deviations. Best approach uses sorting: Time O(mn log mn), Space O(mn).

Common Approaches

✓ Sort and Find Median

⏱️ Time: O(mn log(mn)) Space: O(mn)

Convert 2D grid to 1D array, sort it, and use the median as the target value since median minimizes the sum of absolute deviations. This is much more efficient than trying every possible target.

Try All Possible Targets

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

For each element in the grid, assume it's the target value and calculate how many operations are needed to transform all other elements to this target. Return the minimum operations found.

Sort and Find Median — Algorithm Steps

Step 1: Check if all elements have same remainder when divided by x
Step 2: Flatten grid to 1D array and sort
Step 3: Use median as target and count operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Flatten & Sort

Convert 2D grid to sorted 1D array

Find Median

Median minimizes sum of absolute deviations

Count Operations

Calculate operations to reach median

Code -

solution.c — C

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

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

int solution(int** grid, int gridSize, int* gridColSize, int x) {
    int m = gridSize, n = gridColSize[0];
    
    // Flatten grid and check remainder
    int* nums = (int*)malloc(m * n * sizeof(int));
    int remainder = grid[0][0] % x;
    int idx = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] % x != remainder) {
                free(nums);
                return -1;
            }
            nums[idx++] = grid[i][j];
        }
    }
    
    // Sort to find median
    qsort(nums, m * n, sizeof(int), compare);
    
    // Use median as target
    int median = nums[(m * n) / 2];
    
    // Count operations needed
    int operations = 0;
    for (int i = 0; i < m * n; i++) {
        operations += abs(nums[i] - median) / x;
    }
    
    free(nums);
    return operations;
}

int main() {
    char line[1000];
    int x;
    
    fgets(line, sizeof(line), stdin);
    scanf("%d", &x);
    
    // Parse grid from JSON format - find the array part
    char* start = strstr(line, "[[");
    if (!start) return 1;
    
    // Find the end of the array
    char* end = start;
    int bracket_count = 0;
    while (*end) {
        if (*end == '[') bracket_count++;
        else if (*end == ']') {
            bracket_count--;
            if (bracket_count == 0) {
                end++;
                break;
            }
        }
        end++;
    }
    
    // Extract just the array part
    int len = end - start;
    char* gridStr = (char*)malloc(len + 1);
    strncpy(gridStr, start, len);
    gridStr[len] = '\0';
    
    // Remove outer brackets
    if (gridStr[0] == '[') {
        memmove(gridStr, gridStr + 1, strlen(gridStr));
    }
    if (gridStr[strlen(gridStr) - 1] == ']') {
        gridStr[strlen(gridStr) - 1] = '\0';
    }
    
    // Parse rows
    int grid[100][100];
    int* gridPtrs[100];
    int colSizes[100];
    int rows = 0;
    
    char* row_start = gridStr;
    while (*row_start && rows < 100) {
        // Skip to start of row
        while (*row_start && *row_start != '[') row_start++;
        if (!*row_start) break;
        
        // Find end of this row
        char* row_end = row_start + 1;
        while (*row_end && *row_end != ']') row_end++;
        if (!*row_end) break;
        
        // Parse numbers in this row
        char* p = row_start + 1; // skip [
        int col = 0;
        while (p < row_end && col < 100) {
            while (*p == ' ' || *p == ',') p++;
            if (p >= row_end) break;
            
            grid[rows][col] = (int)strtol(p, &p, 10);
            col++;
        }
        
        gridPtrs[rows] = grid[rows];
        colSizes[rows] = col;
        rows++;
        
        // Move to next row
        row_start = row_end + 1;
        while (*row_start && *row_start == ',') row_start++;
    }
    
    int result = solution(gridPtrs, rows, colSizes, x);
    printf("%d\n", result);
    
    free(gridStr);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn log(mn))

Sorting m*n elements takes O(mn log(mn)) time

⚡ Linearithmic

Space Complexity

O(mn)

Extra array to store all grid elements

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Sort and Find Median — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler