K Highest Ranked Items Within a Price Range

K Highest Ranked Items Within a Price Range - Problem

Imagine you're exploring a treasure map represented as a grid, where each cell can be a wall (0), an empty path (1), or contain an item with a specific price. Starting from your position, you need to find the k highest-ranked items within your budget range.

The ranking system prioritizes items based on:

Distance - Items closer to your starting position rank higher
Price - Among items at the same distance, cheaper ones rank higher
Position - If distance and price are tied, prefer smaller row, then smaller column

You can move in 4 directions (up, down, left, right) and each step takes 1 unit of time. Your goal is to return the k highest-ranked items within the price range [low, high], sorted by their rank from highest to lowest.

Input & Output

example_1.py — Basic Grid Navigation

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

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

💡 Note: Starting from [0,0], we can reach items with prices 2 and 3. The item at [0,1] has price=2 and distance=1, [1,1] has price=3 and distance=2, and [2,1] has price=1 (outside range). Only first two are within [2,3] range.

example_2.py — Multiple Items Same Distance

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

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

💡 Note: From [1,1], items at [0,1] (price=2, dist=1) and [0,2] (price=3, dist=1) are both distance 1 away. Price 2 < 3, so [0,1] ranks higher. Then [0,2] is next best within k=2.

example_3.py — No Valid Items

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

› Output: []

💡 Note: The only item at starting position [1,1] has price=10, which is outside the range [2,5]. No items are within the price range, so return empty array.

Visualization

Tap to expand

Understanding the Visualization

Start BFS Exploration

Begin from the starting position, marking it with distance 0

Explore Adjacent Cells

Visit all reachable neighboring cells, incrementing distance by 1

Continue Level by Level

BFS ensures we explore all cells at distance d before cells at distance d+1

Collect Valid Items

Identify all items within the specified price range and record their distances

Rank and Select

Sort items by distance, price, row, column and return the top k items

Key Takeaway

🎯 Key Insight: BFS is perfect for this problem because it explores cells in order of increasing distance from the start, which is exactly what we need for the primary ranking criterion.

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, DFS explores all possible paths exponentially

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack and visited array for DFS

⚡ Linearithmic Space

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 ≤ pricing[0] ≤ pricing[1] ≤ 10⁵
start.length == 2
0 ≤ start[0] < m
0 ≤ start[1] < n
grid[start[0]][start[1]] != 0
1 ≤ k ≤ 10⁵

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25 Apple 19

The optimal solution uses BFS (Breadth-First Search) to find shortest distances from the starting position to all reachable cells, then collects items within the price range and sorts them by the ranking criteria. BFS naturally explores cells by distance, making it perfect for this pathfinding problem. Time complexity is O(m×n + I×log(I)) where I is the number of valid items.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Paths DFS)	O(4^(m*n))	O(m*n)	Use DFS to find shortest path to every reachable cell, then rank all affordable items
BFS + Sorting (Optimal)	O(mn + Ilog(I))	O(m*n)	Use BFS to find shortest distances, then sort items within price range by ranking criteria

Brute Force (All Paths DFS) — Algorithm Steps

Use DFS from start position to find shortest path to each cell
Collect all items within the price range with their distances
Sort items by ranking criteria (distance, price, row, column)
Return the first k items from the sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Begin from starting position with distance 0

Explore Level 1

Visit all adjacent cells with distance 1

Continue BFS

Keep exploring until all reachable cells are visited

Collect & Sort

Gather items within price range and sort by ranking criteria

Code -

solution.c — C

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

typedef struct {
    int dist, price, row, col;
} Item;

int compare(const void *a, const void *b) {
    Item *ia = (Item*)a, *ib = (Item*)b;
    if (ia->dist != ib->dist) return ia->dist - ib->dist;
    if (ia->price != ib->price) return ia->price - ib->price;
    if (ia->row != ib->row) return ia->row - ib->row;
    return ia->col - ib->col;
}

int** solution(int** grid, int gridSize, int* gridColSize, int* pricing, int pricingSize, int* start, int startSize, int k, int* returnSize, int** returnColumnSizes) {
    int m = gridSize, n = gridColSize[0];
    int low = pricing[0], high = pricing[1];
    int startRow = start[0], startCol = start[1];
    
    // BFS to find shortest distances
    int** distances = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        distances[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            distances[i][j] = -1;
        }
    }
    
    // Simple queue implementation
    int queue[m * n][3];
    int front = 0, rear = 0;
    queue[rear][0] = startRow; queue[rear][1] = startCol; queue[rear][2] = 0;
    rear++;
    distances[startRow][startCol] = 0;
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (front < rear) {
        int row = queue[front][0], col = queue[front][1], dist = queue[front][2];
        front++;
        
        for (int i = 0; i < 4; i++) {
            int newRow = row + directions[i][0], newCol = col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n &&
                grid[newRow][newCol] != 0 && distances[newRow][newCol] == -1) {
                distances[newRow][newCol] = dist + 1;
                queue[rear][0] = newRow; queue[rear][1] = newCol; queue[rear][2] = dist + 1;
                rear++;
            }
        }
    }
    
    // Collect items within price range
    Item items[m * n];
    int itemCount = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (distances[i][j] != -1 && grid[i][j] > 1 &&
                grid[i][j] >= low && grid[i][j] <= high) {
                items[itemCount].dist = distances[i][j];
                items[itemCount].price = grid[i][j];
                items[itemCount].row = i;
                items[itemCount].col = j;
                itemCount++;
            }
        }
    }
    
    // Sort items
    qsort(items, itemCount, sizeof(Item), compare);
    
    // Prepare result
    int resultSize = k < itemCount ? k : itemCount;
    *returnSize = resultSize;
    *returnColumnSizes = (int*)malloc(resultSize * sizeof(int));
    int** result = (int**)malloc(resultSize * sizeof(int*));
    
    for (int i = 0; i < resultSize; i++) {
        (*returnColumnSizes)[i] = 2;
        result[i] = (int*)malloc(2 * sizeof(int));
        result[i][0] = items[i].row;
        result[i][1] = items[i].col;
    }
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(distances[i]);
    }
    free(distances);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, DFS explores all possible paths exponentially

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack and visited array for DFS

⚡ Linearithmic Space

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 ≤ pricing[0] ≤ pricing[1] ≤ 10⁵
start.length == 2
0 ≤ start[0] < m
0 ≤ start[1] < n
grid[start[0]][start[1]] != 0
1 ≤ k ≤ 10⁵

52.3K Views

Medium-High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (All Paths DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler