Matrix Cells in Distance Order - Practice Coding Problems

Matrix Cells in Distance Order - Problem

Array Math Geometry Sorting Matrix Easy

Matrix Cells in Distance Order

Imagine you're standing at a specific position in a grid-based city map, and you want to visit all locations in the city, starting with the closest ones first!

You are given four integers: rows, cols, rCenter, and cCenter. There is a rows × cols matrix (like a city grid), and you are currently standing at coordinates (rCenter, cCenter).

Your task: Return the coordinates of all cells in the matrix, sorted by their Manhattan distance from your current position (rCenter, cCenter). Start with the smallest distance and work your way to the largest distance.

The Manhattan distance between two cells (r1, c1) and (r2, c2) is calculated as: |r1 - r2| + |c1 - c2|. This is like walking through city blocks - you can only move horizontally or vertically, not diagonally.

Note: You may return coordinates with the same distance in any order.

Input & Output

example_1.py — Basic 2x3 Matrix

$ Input: rows = 1, cols = 2, rCenter = 0, cCenter = 0

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

💡 Note: The distances are: (0,0)→0, (0,1)→1. So we return cells in order of increasing distance.

example_2.py — 3x3 Matrix with Center

$ Input: rows = 2, cols = 3, rCenter = 1, cCenter = 2

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

💡 Note: Distances: (1,2)→0, (0,2)→1, (1,1)→1, (1,0)→2, (0,1)→2, (0,0)→3. Cells with same distance can be in any order.

example_3.py — Single Cell Matrix

$ Input: rows = 1, cols = 1, rCenter = 0, cCenter = 0

› Output: [[0,0]]

💡 Note: Only one cell exists, so it's returned as the only element with distance 0.

Constraints

1 ≤ rows, cols ≤ 100
0 ≤ rCenter < rows
0 ≤ cCenter < cols

Visualization

Tap to expand

Understanding the Visualization

Center Point

Start at (rCenter, cCenter) with distance 0 - this is where the stone hits the water

Distance 1 Ring

Cells at Manhattan distance 1 form a diamond shape around the center

Distance 2 Ring

The next ring expands outward, containing all cells at distance 2

Continue Expansion

Keep expanding until all matrix cells are covered

Key Takeaway

🎯 Key Insight: Manhattan distance creates predictable square 'ripples' that expand outward. By using bucket sort on the limited range of distance values, we can collect coordinates in perfect distance order without expensive sorting operations.

Asked in

G Google 23 a Amazon 18 f Facebook 15 ⊞ Microsoft 12

The optimal solution uses bucket sort by distance. Instead of calculating all distances and sorting them (O(RC log RC)), we create buckets for each possible distance value (0 to max_distance) and directly place coordinates into the correct bucket. Then we collect results by iterating through buckets in order, achieving O(RC) time complexity. This works because Manhattan distances are small integers bounded by the matrix dimensions.

Common Approaches

Approach	Time	Space	Notes
✓ Bucket Sort by Distance (Optimal)	O(RC)	O(max_distance)	Group coordinates by distance value, then output in distance order
Brute Force (Calculate All Distances + Sort)	O(RC log(RC))	O(RC)	Generate all coordinates, calculate Manhattan distances, then sort by distance

Bucket Sort by Distance (Optimal) — Algorithm Steps

Calculate the maximum possible distance in the matrix
Create buckets (lists) for each distance from 0 to maxDistance
Iterate through all matrix cells
For each cell, calculate its distance and add coordinates to the corresponding bucket
Iterate through buckets in distance order and collect all coordinates

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Distance Buckets

Create empty buckets for distances 0, 1, 2, ..., max_distance

Distribute Cells

Calculate each cell's distance and place it in the corresponding bucket

Collect in Order

Iterate through buckets from distance 0 to max_distance

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

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

int** allCellsDistOrder(int rows, int cols, int rCenter, int cCenter, int* returnSize, int** returnColumnSizes) {
    // Calculate maximum possible distance
    int maxDistance = max(rCenter, rows - 1 - rCenter) + max(cCenter, cols - 1 - cCenter);
    
    // Create buckets for each distance
    int** buckets = (int**)malloc((maxDistance + 1) * sizeof(int*));
    int* bucketSizes = (int*)calloc(maxDistance + 1, sizeof(int));
    int* bucketCapacities = (int*)malloc((maxDistance + 1) * sizeof(int));
    
    // Initialize buckets
    for (int i = 0; i <= maxDistance; i++) {
        bucketCapacities[i] = 10; // Initial capacity
        buckets[i] = (int*)malloc(bucketCapacities[i] * 2 * sizeof(int));
    }
    
    // Place each cell in the appropriate bucket
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            int distance = abs_val(r - rCenter) + abs_val(c - cCenter);
            
            // Expand bucket if needed
            if (bucketSizes[distance] * 2 >= bucketCapacities[distance] * 2) {
                bucketCapacities[distance] *= 2;
                buckets[distance] = (int*)realloc(buckets[distance], bucketCapacities[distance] * 2 * sizeof(int));
            }
            
            buckets[distance][bucketSizes[distance] * 2] = r;
            buckets[distance][bucketSizes[distance] * 2 + 1] = c;
            bucketSizes[distance]++;
        }
    }
    
    // Prepare result
    int totalCells = rows * cols;
    int** result = (int**)malloc(totalCells * sizeof(int*));
    *returnColumnSizes = (int*)malloc(totalCells * sizeof(int));
    
    int idx = 0;
    for (int d = 0; d <= maxDistance; d++) {
        for (int i = 0; i < bucketSizes[d]; i++) {
            result[idx] = (int*)malloc(2 * sizeof(int));
            result[idx][0] = buckets[d][i * 2];
            result[idx][1] = buckets[d][i * 2 + 1];
            (*returnColumnSizes)[idx] = 2;
            idx++;
        }
        free(buckets[d]);
    }
    
    *returnSize = totalCells;
    free(buckets);
    free(bucketSizes);
    free(bucketCapacities);
    
    return result;
}

int main() {
    int rows, cols, rCenter, cCenter;
    scanf("%d %d %d %d", &rows, &cols, &rCenter, &cCenter);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = allCellsDistOrder(rows, cols, rCenter, cCenter, &returnSize, &returnColumnSizes);
    
    for (int i = 0; i < returnSize; i++) {
        printf("[%d, %d]\n", result[i][0], result[i][1]);
        free(result[i]);
    }
    
    free(result);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(RC)

O(RC) to iterate through all cells and place them in buckets, O(RC) to collect results from buckets

✓ Linear Growth

Space Complexity

O(max_distance)

Need buckets for each possible distance value, max distance is (rows-1) + (cols-1)

⚡ Linearithmic Space

76.4K Views

Medium Frequency

~15 min Avg. Time

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

Bucket Sort by Distance (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler