K Highest Ranked Items Within a Price Range

K Highest Ranked Items Within a Price Range - Problem

You are given a 0-indexed 2D integer array grid of size m × n that represents a map of items in a shop. The integers in the grid represent:

0 represents a wall that you cannot pass through
1 represents an empty cell that you can freely move to and from
All other positive integers represent the price of an item in that cell

It takes 1 step to travel between adjacent grid cells (up, down, left, right).

You are given integer arrays pricing = [low, high] and start = [row, col] indicating your starting position and price range of interest. You are also given an integer k.

Find the positions of the k highest-ranked items whose prices are within the given price range. The rank is determined by the first differing criteria:

Distance: shorter distance from start has higher rank
Price: lower price has higher rank (within price range)
Row number: smaller row number has higher rank
Column number: smaller column number has higher rank

Return the k highest-ranked items within the price range sorted by rank. If fewer than k items exist, return all of them.

Input & Output

Example 1 — Basic Case

$ Input: grid = [[1,2,3,1],[1,2,3,1],[1,2,3,1]], pricing = [2,3], start = [0,1], k = 3

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

💡 Note: Start at [0,1] with price=2 (dist=0). At distance 1, we have [0,2] price=3 and [1,1] price=2. Since [1,1] has lower price, it ranks higher than [0,2]. Final ranking: [0,1], [1,1], [0,2].

Example 2 — Different Start Position

$ Input: grid = [[1,2,3,1],[1,2,3,1],[1,2,3,1]], pricing = [2,3], start = [2,1], k = 2

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

💡 Note: Start at [2,1] with price=2. Closest item with same distance and price is [1,1] price=2. Both have distance 0 and 1 respectively.

Example 3 — Limited Items in Range

$ Input: grid = [[1,5,7,1],[1,2,3,1]], pricing = [2,3], start = [0,1], k = 5

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

💡 Note: Only 2 items are in price range [2,3]: [1,1] with price=2 and [1,2] with price=3. Return all available items even though k=5.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 10⁵
1 ≤ m × n ≤ 10⁵
0 ≤ grid[i][j] ≤ 10⁵
pricing.length == 2
2 ≤ low ≤ high ≤ 10⁵
start.length == 2
0 ≤ row ≤ m - 1
0 ≤ col ≤ n - 1
grid[row][col] > 0
1 ≤ k ≤ m × n

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8 F Facebook 6

The key insight is to use BFS to naturally get distances from the start position, then sort items by the four ranking criteria. The BFS + Sort approach is most straightforward - find all reachable items within price range using BFS, then sort by (distance, price, row, col). Time: O(mn + items×log(items)), Space: O(mn).

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

BFS + Complete Sort

⏱️ Time: O(mn + items*log(items)) Space: O(mn)

First, use BFS to explore all reachable cells and find items within price range. Calculate distances for each item, then sort all found items by the four ranking criteria.

BFS with Early Termination

⏱️ Time: O(mn + k*log(k)) Space: O(mn)

Instead of finding all items first, use BFS where we process cells in order of distance. For each distance level, collect items and sort them, allowing early termination once we have k items.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

int solution(int** matrix, int m, int n) {
    if (m == 0 || n == 0) return 0;
    
    int* heights = (int*)calloc(n, sizeof(int));
    int* sortedHeights = (int*)malloc(n * sizeof(int));
    int maxArea = 0;
    
    for (int i = 0; i < m; i++) {
        // Update heights for current row
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 1) {
                heights[j]++;
            } else {
                heights[j] = 0;
            }
        }
        
        // Copy and sort heights in descending order
        memcpy(sortedHeights, heights, n * sizeof(int));
        qsort(sortedHeights, n, sizeof(int), compare);
        
        // Find maximum rectangle area
        for (int width = 1; width <= n; width++) {
            int height = sortedHeights[width - 1];
            if (height == 0) break;  // No point checking further
            int area = width * height;
            if (area > maxArea) maxArea = area;
        }
    }
    
    free(heights);
    free(sortedHeights);
    return maxArea;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input format [[1,0,1],[1,1,0]]
    int m = 0, n = 0;
    
    // Count rows and columns
    char* temp = strdup(line);
    char* ptr = temp;
    while (*ptr && *ptr != '[') ptr++; // Skip to first '['
    if (*ptr) ptr++; // Skip first '['
    
    // Count rows by counting '],'
    char* row_ptr = ptr;
    while (*row_ptr) {
        if (*row_ptr == '[') {
            m++;
            if (n == 0) {
                // Count columns in first row
                char* col_ptr = row_ptr + 1;
                while (*col_ptr && *col_ptr != ']') {
                    if (*col_ptr == '0' || *col_ptr == '1') n++;
                    col_ptr++;
                }
            }
        }
        row_ptr++;
    }
    free(temp);
    
    if (m == 0 || n == 0) {
        printf("0\n");
        return 0;
    }
    
    // Allocate matrix
    int** matrix = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        matrix[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Parse the actual values
    ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Skip to first '['
    if (*ptr) ptr++; // Skip first '['
    
    int row = 0;
    while (*ptr && row < m) {
        if (*ptr == '[') {
            ptr++; // Skip '['
            int col = 0;
            while (*ptr && *ptr != ']' && col < n) {
                if (*ptr == '0') {
                    matrix[row][col++] = 0;
                } else if (*ptr == '1') {
                    matrix[row][col++] = 1;
                }
                ptr++;
            }
            row++;
        }
        ptr++;
    }
    
    printf("%d\n", solution(matrix, m, n));
    
    for (int i = 0; i < m; i++) free(matrix[i]);
    free(matrix);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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