Minimize Maximum Value in a Grid - Practice Coding Problems

Minimize Maximum Value in a Grid - Problem

Array Union Find Graph Topological Sort Sorting Matrix Hard

You are given an m x n integer matrix grid containing distinct positive integers. Your task is to replace each integer in the matrix with a positive integer while satisfying these crucial conditions:

Preserve relative order: The relative order of every two elements that are in the same row or column must stay the same after replacements
Minimize maximum: The maximum number in the matrix after replacements should be as small as possible

The relative order condition means: if grid[r1][c1] > grid[r2][c2] where either r1 == r2 or c1 == c2, then this inequality must remain true after replacements.

Example: For matrix [[2, 4, 5], [7, 3, 9]], valid replacements include [[1, 2, 3], [2, 1, 4]] or [[1, 2, 3], [3, 1, 4]].

Return the resulting matrix. If multiple valid answers exist, return any of them.

Input & Output

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find with Coordinate Compression	O(mn log(mn))	O(mn)	Group equivalent positions and assign ranks using coordinate compression
Topological Sort with Constraint Graph	O(m²n + mn²)	O(m²n + mn²)	Build dependency graph, then assign values using topological ordering
Brute Force (Generate All Permutations)	O((m*n)!)	O(m*n)	Try all possible value assignments and check constraints

Union-Find with Coordinate Compression — Algorithm Steps

Sort all matrix positions by their values
Use Union-Find to group positions with equal constraints
For each position, determine its rank in its row and column
Use coordinate compression: assign value = max(row_rank, col_rank) + 1
Build result matrix with compressed coordinates

Code -

solution.c — C

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

typedef struct {
    int value, row, col;
} Position;

int compare_positions(const void* a, const void* b) {
    Position* pos_a = (Position*)a;
    Position* pos_b = (Position*)b;
    return pos_a->value - pos_b->value;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int** minMaxGrid(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    
    // Step 1: Create and sort all positions by value
    Position* positions = (Position*)malloc(m * n * sizeof(Position));
    int pos_count = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            positions[pos_count].value = grid[i][j];
            positions[pos_count].row = i;
            positions[pos_count].col = j;
            pos_count++;
        }
    }
    
    qsort(positions, pos_count, sizeof(Position), compare_positions);
    
    // Step 2: Use coordinate compression
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)calloc(n, sizeof(int));
    }
    
    int* rowMax = (int*)calloc(m, sizeof(int));  // max value assigned in each row so far
    int* colMax = (int*)calloc(n, sizeof(int));  // max value assigned in each column so far
    
    int i = 0;
    while (i < pos_count) {
        // Group positions with the same value
        Position* sameValuePositions = (Position*)malloc(m * n * sizeof(Position));
        int sameValueCount = 0;
        int currentValue = positions[i].value;
        
        while (i < pos_count && positions[i].value == currentValue) {
            sameValuePositions[sameValueCount] = positions[i];
            sameValueCount++;
            i++;
        }
        
        // For each position with same value, determine its rank
        for (int j = 0; j < sameValueCount; j++) {
            int row = sameValuePositions[j].row;
            int col = sameValuePositions[j].col;
            // The value must be greater than all previous values in its row and column
            result[row][col] = max(rowMax[row], colMax[col]) + 1;
        }
        
        // Update rowMax and colMax after processing all positions with same value
        for (int j = 0; j < sameValueCount; j++) {
            int row = sameValuePositions[j].row;
            int col = sameValuePositions[j].col;
            rowMax[row] = max(rowMax[row], result[row][col]);
            colMax[col] = max(colMax[col], result[row][col]);
        }
        
        free(sameValuePositions);
    }
    
    free(positions);
    free(rowMax);
    free(colMax);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn log(mn))

Sorting positions takes O(mn log(mn)), Union-Find operations are nearly O(1) amortized

⚡ Linearithmic

Space Complexity

O(mn)

Space for Union-Find parent array and position sorting

⚡ Linearithmic Space

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