Rank Transform of a Matrix

Rank Transform of a Matrix - Problem

Array Union Find Graph Topological Sort Sorting Matrix Hard

Given an m x n matrix, return a new matrix answer where answer[row][col] is the rank of matrix[row][col].

The rank is an integer that represents how large an element is compared to other elements. It is calculated using the following rules:

The rank is an integer starting from 1.
If two elements p and q are in the same row or column, then:
- If p < q then rank(p) < rank(q)
- If p == q then rank(p) == rank(q)
- If p > q then rank(p) > rank(q)
The rank should be as small as possible.

The test cases are generated so that answer is unique under the given rules.

Input & Output

Example 1 — Basic Matrix

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

› Output: [[1,2],[2,3]]

💡 Note: Value 1 gets rank 1, value 2 gets rank 2, value 3 gets rank 2 (constrained by row/column), value 4 gets rank 3

Example 2 — Equal Elements

$ Input: matrix = [[7,7],[7,7]]

› Output: [[1,1],[1,1]]

💡 Note: All elements have the same value, so they all get rank 1

Example 3 — Complex Constraints

$ Input: matrix = [[20,-21,14],[-19,4,19],[22,-47,24]]

› Output: [[4,2,3],[1,5,6],[6,1,7]]

💡 Note: Ranks assigned respecting row and column ordering constraints while keeping them as small as possible

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 500
-10⁹ ≤ matrix[row][col] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use Union-Find to group equal elements in the same row/column, then apply topological sort to assign minimum ranks while respecting ordering constraints. Best approach uses Union-Find with Topological Sort. Time: O(m×n×log(m×n)), Space: O(m×n)

Common Approaches

✓ Brute Force Coordinate Compression

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

Extract all unique values, sort them, and assign ranks. Then for each cell, find its rank by looking up its value in the sorted list.

Union-Find with Topological Sort

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

Group equal elements in same row/column using Union-Find, then use topological sort to determine ranks while respecting ordering constraints.

Brute Force Coordinate Compression — Algorithm Steps

Step 1: Extract all unique values from matrix
Step 2: Sort unique values and create value-to-rank mapping
Step 3: Replace each matrix cell with its corresponding rank

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Get all unique values from matrix

Sort & Map

Sort values and assign sequential ranks

Replace

Replace each cell with its value's rank

Code -

solution.c — C

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

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

int compare_positions(const void* a, const void* b) {
    Position* pa = (Position*)a;
    Position* pb = (Position*)b;
    return pa->val - pb->val;
}

typedef struct {
    int* parent;
    int* rank;
    int size;
} UnionFind;

UnionFind* create_uf(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->size = n;
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    return uf;
}

int find_root(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find_root(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void union_sets(UnionFind* uf, int x, int y) {
    int px = find_root(uf, x);
    int py = find_root(uf, y);
    if (px == py) return;
    
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
}

void free_uf(UnionFind* uf) {
    free(uf->parent);
    free(uf->rank);
    free(uf);
}

int** solution(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = matrixSize;
    *returnColumnSizes = (int*)malloc(matrixSize * sizeof(int));
    
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return matrix;
    }
    
    int m = matrixSize, n = matrixColSize[0];
    
    // Create position array
    Position* positions = (Position*)malloc(m * n * sizeof(Position));
    int count = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            positions[count].val = matrix[i][j];
            positions[count].row = i;
            positions[count].col = j;
            count++;
        }
    }
    
    // Sort by value
    qsort(positions, count, sizeof(Position), compare_positions);
    
    // Create result matrix
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
        for (int j = 0; j < n; j++) {
            result[i][j] = 0;
        }
    }
    
    // Track max rank in each row and column
    int* rowMax = (int*)calloc(m, sizeof(int));
    int* colMax = (int*)calloc(n, sizeof(int));
    
    // Process positions in sorted order
    int i = 0;
    while (i < count) {
        int currentVal = positions[i].val;
        int groupStart = i;
        
        // Find all positions with same value
        while (i < count && positions[i].val == currentVal) {
            i++;
        }
        
        int groupSize = i - groupStart;
        
        if (groupSize == 1) {
            // Single position
            int row = positions[groupStart].row;
            int col = positions[groupStart].col;
            int rank = rowMax[row] + 1;
            if (colMax[col] + 1 > rank) rank = colMax[col] + 1;
            result[row][col] = rank;
            rowMax[row] = rank;
            colMax[col] = rank;
        } else {
            // Multiple positions with same value - use Union-Find
            UnionFind* uf = create_uf(groupSize);
            
            // Union positions in same row or column
            for (int idx1 = 0; idx1 < groupSize; idx1++) {
                for (int idx2 = idx1 + 1; idx2 < groupSize; idx2++) {
                    int r1 = positions[groupStart + idx1].row;
                    int c1 = positions[groupStart + idx1].col;
                    int r2 = positions[groupStart + idx2].row;
                    int c2 = positions[groupStart + idx2].col;
                    if (r1 == r2 || c1 == c2) {
                        union_sets(uf, idx1, idx2);
                    }
                }
            }
            
            // Process each component
            int* processed = (int*)calloc(groupSize, sizeof(int));
            for (int idx = 0; idx < groupSize; idx++) {
                if (processed[idx]) continue;
                
                int root = find_root(uf, idx);
                
                // Find all positions in this component
                int* component = (int*)malloc(groupSize * sizeof(int));
                int componentSize = 0;
                for (int j = 0; j < groupSize; j++) {
                    if (find_root(uf, j) == root) {
                        component[componentSize++] = j;
                        processed[j] = 1;
                    }
                }
                
                // Find minimum rank needed for this component
                int minRank = 1;
                for (int j = 0; j < componentSize; j++) {
                    int pos_idx = groupStart + component[j];
                    int row = positions[pos_idx].row;
                    int col = positions[pos_idx].col;
                    if (rowMax[row] + 1 > minRank) minRank = rowMax[row] + 1;
                    if (colMax[col] + 1 > minRank) minRank = colMax[col] + 1;
                }
                
                // Assign rank to all positions in component
                for (int j = 0; j < componentSize; j++) {
                    int pos_idx = groupStart + component[j];
                    int row = positions[pos_idx].row;
                    int col = positions[pos_idx].col;
                    result[row][col] = minRank;
                    rowMax[row] = minRank;
                    colMax[col] = minRank;
                }
                
                free(component);
            }
            
            free(processed);
            free_uf(uf);
        }
    }
    
    free(positions);
    free(rowMax);
    free(colMax);
    return result;
}

int main() {
    static int matrix[500][500];
    int m = 0, n = 0;
    
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Simple parsing for [[a,b],[c,d]] format
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']' && m < 500) {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']' && n < 500) {
                while (*ptr == ' ' || *ptr == '\t') ptr++; // Skip whitespace
                if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
                    long val = strtol(ptr, &ptr, 10);
                    matrix[m][n] = (int)val;
                    n++;
                    while (*ptr == ' ' || *ptr == '\t') ptr++; // Skip whitespace
                    if (*ptr == ',') ptr++;
                } else {
                    ptr++;
                }
            }
            if (n > 0) m++;
        }
        ptr++;
    }
    
    if (m == 0) {
        printf("[]\n");
        return 0;
    }
    
    int* matrixColSize = (int*)malloc(m * sizeof(int));
    int** matrixPtrs = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        matrixColSize[i] = n;
        matrixPtrs[i] = matrix[i];
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(matrixPtrs, m, matrixColSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(matrixColSize);
    free(matrixPtrs);
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×log(m×n))

Extracting values O(m×n), sorting unique values O(k×log k) where k ≤ m×n, mapping back O(m×n)

⚡ Linearithmic

Space Complexity

O(m×n)

Storing unique values and result matrix

⚡ Linearithmic Space

28.0K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Coordinate Compression — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler