Formatted question description: https://leetcode.ca/all/2146.html

# 2146. K Highest Ranked Items Within a Price Range (Medium)

You are given a **0-indexed** 2D integer array `grid`

of size `m x n`

that represents a map of the items in a shop. The integers in the grid represent the following:

`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. You may also freely move to and from these item cells.

It takes `1`

step to travel between adjacent grid cells.

You are also given integer arrays `pricing`

and `start`

where `pricing = [low, high]`

and `start = [row, col]`

indicates that you start at the position `(row, col)`

and are interested only in items with a price in the range of `[low, high]`

(**inclusive**). You are further given an integer `k`

.

You are interested in the **positions** of the `k`

**highest-ranked** items whose prices are **within** the given price range. The rank is determined by the **first** of these criteria that is different:

- Distance, defined as the length of the shortest path from the
`start`

(**shorter**distance has a higher rank). - Price (
**lower**price has a higher rank, but it must be**in the price range**). - The row number (
**smaller**row number has a higher rank). - The column number (
**smaller**column number has a higher rank).

Return *the *`k`

* highest-ranked items within the price range sorted by their rank (highest to lowest)*. If there are fewer than

`k`

reachable items within the price range, return *.*

**all**of them

**Example 1:**

Input:grid = [[1,2,0,1],[1,3,0,1],[0,2,5,1]], pricing = [2,5], start = [0,0], k = 3Output:[[0,1],[1,1],[2,1]]Explanation:You start at (0,0). With a price range of [2,5], we can take items from (0,1), (1,1), (2,1) and (2,2). The ranks of these items are: - (0,1) with distance 1 - (1,1) with distance 2 - (2,1) with distance 3 - (2,2) with distance 4 Thus, the 3 highest ranked items in the price range are (0,1), (1,1), and (2,1).

**Example 2:**

Input:grid = [[1,2,0,1],[1,3,3,1],[0,2,5,1]], pricing = [2,3], start = [2,3], k = 2Output:[[2,1],[1,2]]Explanation:You start at (2,3). With a price range of [2,3], we can take items from (0,1), (1,1), (1,2) and (2,1). The ranks of these items are: - (2,1) with distance 2, price 2 - (1,2) with distance 2, price 3 - (1,1) with distance 3 - (0,1) with distance 4 Thus, the 2 highest ranked items in the price range are (2,1) and (1,2).

**Example 3:**

Input:grid = [[1,1,1],[0,0,1],[2,3,4]], pricing = [2,3], start = [0,0], k = 3Output:[[2,1],[2,0]]Explanation:You start at (0,0). With a price range of [2,3], we can take items from (2,0) and (2,1). The ranks of these items are: - (2,1) with distance 5 - (2,0) with distance 6 Thus, the 2 highest ranked items in the price range are (2,1) and (2,0). Note that k = 3 but there are only 2 reachable items within the price range.

**Constraints:**

`m == grid.length`

`n == grid[i].length`

`1 <= m, n <= 10`

^{5}`1 <= m * n <= 10`

^{5}`0 <= grid[i][j] <= 10`

^{5}`pricing.length == 2`

`2 <= low <= high <= 10`

^{5}`start.length == 2`

`0 <= row <= m - 1`

`0 <= col <= n - 1`

`grid[row][col] > 0`

`1 <= k <= m * n`

**Similar Questions**:

## Solution 1. BFS + Sorting

BFS to visit all the cells reachable. If the price of the cell is within the range, add this cell into the answer array.

Sort the answer array using the criteria specified, and only keep the first `k`

cells.

```
// OJ: https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/
// Time: O(MNlog(MN))
// Space: O(MN)
class Solution {
public:
vector<vector<int>> highestRankedKItems(vector<vector<int>>& A, vector<int>& P, vector<int>& start, int k) {
int M = A.size(), N = A[0].size(), step = 0, dirs[4][2] = { {0,1},{0,-1},{1,0},{-1,0} };
queue<pair<int, int>> q{ { {start[0], start[1]} }};
vector<vector<int>> dist(M, vector<int>(N, INT_MAX)), ans; // dist[x][y] is the shortest distance from (x,y) to `start`.
dist[start[0]][start[1]] = 0;
while (q.size()) {
int cnt = q.size();
while (cnt--) {
auto [x, y] = q.front();
q.pop();
if (A[x][y] >= P[0] && A[x][y] <= P[1]) ans.push_back({x, y});
for (auto &[dx, dy] : dirs) {
int a = x + dx, b = y + dy;
if (a < 0 || b < 0 || a >= M || b >= N || A[a][b] == 0 || dist[a][b] != INT_MAX) continue;
dist[a][b] = step + 1;
q.emplace(a, b);
}
}
++step;
}
sort(begin(ans), end(ans), [&](auto &a, auto &b) {
int x1 = a[0], y1 = a[1], x2 = b[0], y2 = b[1];
int d1 = dist[x1][y1], d2 = dist[x2][y2];
if (d1 != d2) return d1 < d2;
int p1 = A[x1][y1], p2 = A[x2][y2];
if (p1 != p2) return p1 < p2;
return a < b;
});
if (ans.size() > k) ans.resize(k);
return ans;
}
};
```

## Solution 2. BFS + Heap

Instead of keeping all the reachable cells in `ans`

, we can use a heap to keep only the optimal `k`

cells.

Since we are doing BFS, we are already visiting the cells in ascending order of distance layer by layer, so we don’t need to sort by distance.

```
// OJ: https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/
// Time: O(MNlogK)
// Space: O(MN)
class Solution {
public:
vector<vector<int>> highestRankedKItems(vector<vector<int>>& A, vector<int>& P, vector<int>& start, int k) {
int M = A.size(), N = A[0].size(), step = 0, dirs[4][2] = { {0,1},{0,-1},{1,0},{-1,0} };
queue<pair<int, int>> q{ { {start[0], start[1]} }};
vector<vector<int>> ans;
vector<vector<bool>> seen(M, vector<bool>(N));
seen[start[0]][start[1]] = true;
while (q.size() && ans.size() < k) {
int cnt = q.size();
vector<vector<int>> tmp;
while (cnt--) {
auto [x, y] = q.front();
q.pop();
if (A[x][y] >= P[0] && A[x][y] <= P[1]) tmp.push_back({A[x][y], x, y});
for (auto &[dx, dy] : dirs) {
int a = x + dx, b = y + dy;
if (a < 0 || b < 0 || a >= M || b >= N || A[a][b] == 0 || seen[a][b]) continue;
seen[a][b] = true;
q.emplace(a, b);
}
}
sort(begin(tmp), end(tmp));
++step;
for (auto c : tmp) {
ans.push_back({c[1], c[2]});
if (ans.size() == k) break;
}
}
return ans;
}
};
```

## Discuss

https://leetcode.com/problems/k-highest-ranked-items-within-a-price-range/discuss/1709689/C%2B%2B-BFS-%2B-Sorting-O(MNlog(MN))-or-Heap-O(MNlogK)