K Highest Ranked Items Within a Price Range solution and explanation

import heapq
from collections import deque

def k_highest_ranked_items(grid, pricing, start, k):
    m, n = len(grid), len(grid[0])
    low, high = pricing
    start_x, start_y = start
    directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
    queue = deque([(start_x, start_y, 0)])  # (x, y, distance)
    visited = set()
    visited.add((start_x, start_y))
    items = []

    while queue:
        x, y, distance = queue.popleft()

        if low <= grid[x][y] <= high:
            heapq.heappush(items, (distance, grid[x][y], x, y))

        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < m and 0 <= ny < n and (nx, ny) not in visited and grid[nx][ny] != 0:
                visited.add((nx, ny))
                queue.append((nx, ny, distance + 1))

    result = []
    while items and len(result) < k:
        result.append(heapq.heappop(items)[2:])

    return result

function kHighestRankedItems(grid, pricing, start, k) {
    const [low, high] = pricing;
    const [startRow, startCol] = start;
    const m = grid.length, n = grid[0].length;
    const directions = [[1, 0], [-1, 0], [0, 1], [0, -1]];

    const queue = [[startRow, startCol, 0]]; // x, y, distance
    const visited = new Set([startRow * n + startCol]);
    const items = [];

    while (queue.length) {
        const [x, y, distance] = queue.shift();

        if (grid[x][y] >= low && grid[x][y] <= high) {
            items.push([distance, grid[x][y], x, y]);
        }

        for (const [dx, dy] of directions) {
            const nx = x + dx, ny = y + dy;
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && !visited.has(nx * n + ny) && grid[nx][ny] !== 0) {
                visited.add(nx * n + ny);
                queue.push([nx, ny, distance + 1]);
            }
        }
    }

    items.sort((a, b) => 
        a[0] - b[0] || a[1] - b[1] || a[2] - b[2] || a[3] - b[3]
    );

    return items.slice(0, k).map(([, , x, y]) => [x, y]);
}

import java.util.*;

public List<List<Integer>> kHighestRankedItems(int[][] grid, int[] pricing, int[] start, int k) {
    int m = grid.length, n = grid[0].length;
    int low = pricing[0], high = pricing[1];
    int startX = start[0], startY = start[1];
    int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> 
        a[0] != b[0] ? a[0] - b[0] : (a[1] != b[1] ? a[1] - b[1] : (a[2] != b[2] ? a[2] - b[2] : a[3] - b[3]))));
    Queue<int[]> queue = new ArrayDeque<>();
    boolean[][] visited = new boolean[m][n];

    queue.add(new int[]{startX, startY, 0});
    visited[startX][startY] = true;

    while (!queue.isEmpty()) {
        int[] current = queue.poll();
        int x = current[0], y = current[1], dist = current[2];

        if (grid[x][y] <= high && grid[x][y] >= low) {
            pq.offer(new int[]{dist, grid[x][y], x, y});
            if (pq.size() > k) pq.poll();
        }

        for (int[] dir : directions) {
            int nx = x + dir[0], ny = y + dir[1];
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && !visited[nx][ny] && grid[nx][ny] != 0) {
                visited[nx][ny] = true;
                queue.offer(new int[]{nx, ny, dist + 1});
            }
        }
    }

    List<List<Integer>> result = new ArrayList<>();
    while (!pq.isEmpty()) {
        int[] item = pq.poll();
        result.add(Arrays.asList(item[2], item[3]));
    }
    Collections.reverse(result);
    return result;
}

#include <vector>
#include <queue>
#include <tuple>
using namespace std;

vector<vector<int>> kHighestRankedItems(vector<vector<int>>& grid, vector<int>& pricing, vector<int>& start, int k) {
    int m = grid.size(), n = grid[0].size();
    int low = pricing[0], high = pricing[1];
    int startX = start[0], startY = start[1];
    vector<pair<int, int>> directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    auto cmp = [](const tuple<int, int, int, int>& a, const tuple<int, int, int, int>& b) {
        return get<0>(a) > get<0>(b) || (get<0>(a) == get<0>(b) && get<1>(a) > get<1>(b)) ||
               (get<0>(a) == get<0>(b) && get<1>(a) == get<1>(b) && get<2>(a) > get<2>(b)) ||
               (get<0>(a) == get<0>(b) && get<1>(a) == get<1>(b) && get<2>(a) == get<2>(b) && get<3>(a) > get<3>(b));
    };
    priority_queue<tuple<int, int, int, int>, vector<tuple<int, int, int, int>>, decltype(cmp)> pq(cmp);
    queue<tuple<int, int, int>> q;
    vector<vector<bool>> visited(m, vector<bool>(n, false));

    q.emplace(startX, startY, 0);
    visited[startX][startY] = true;

    while (!q.empty()) {
        auto [x, y, dist] = q.front(); q.pop();
        if (grid[x][y] <= high && grid[x][y] >= low) {
            pq.emplace(dist, grid[x][y], x, y);
            if (pq.size() > k) pq.pop();
        }
        for (auto &[dx, dy] : directions) {
            int nx = x + dx, ny = y + dy;
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && !visited[nx][ny] && grid[nx][ny] != 0) {
                visited[nx][ny] = true;
                q.emplace(nx, ny, dist + 1);
            }
        }
    }

    vector<vector<int>> result;
    while (!pq.empty()) {
        auto [dist, price, x, y] = pq.top(); pq.pop();
        result.push_back({x, y});
    }
    reverse(result.begin(), result.end());
    return result;
}

function highestRankedKItems(
    grid: number[][],
    pricing: number[],
    start: number[],
    k: number,
): number[][] {
    const [m, n] = [grid.length, grid[0].length];
    const [row, col] = start;
    const [low, high] = pricing;
    let q: [number, number][] = [[row, col]];
    const pq: [number, number, number, number][] = [];
    if (low <= grid[row][col] && grid[row][col] <= high) {
        pq.push([0, grid[row][col], row, col]);
    }
    grid[row][col] = 0;
    const dirs = [-1, 0, 1, 0, -1];
    for (let step = 1; q.length > 0; ++step) {
        const nq: [number, number][] = [];
        for (const [x, y] of q) {
            for (let j = 0; j < 4; j++) {
                const nx = x + dirs[j];
                const ny = y + dirs[j + 1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] > 0) {
                    if (low <= grid[nx][ny] && grid[nx][ny] <= high) {
                        pq.push([step, grid[nx][ny], nx, ny]);
                    }
                    grid[nx][ny] = 0;
                    nq.push([nx, ny]);
                }
            }
        }
        q = nq;
    }
    pq.sort((a, b) => {
        if (a[0] !== b[0]) return a[0] - b[0];
        if (a[1] !== b[1]) return a[1] - b[1];
        if (a[2] !== b[2]) return a[2] - b[2];
        return a[3] - b[3];
    });
    const ans: number[][] = [];
    for (let i = 0; i < Math.min(k, pq.length); i++) {
        ans.push([pq[i][2], pq[i][3]]);
    }
    return ans;
}

func highestRankedKItems(grid [][]int, pricing []int, start []int, k int) (ans [][]int) {
	m, n := len(grid), len(grid[0])
	row, col := start[0], start[1]
	low, high := pricing[0], pricing[1]
	q := [][2]int{{row, col}}
	pq := [][]int{}
	if low <= grid[row][col] && grid[row][col] <= high {
		pq = append(pq, []int{0, grid[row][col], row, col})
	}
	grid[row][col] = 0
	dirs := [5]int{-1, 0, 1, 0, -1}
	for step := 1; len(q) > 0; step++ {
		for sz := len(q); sz > 0; sz-- {
			x, y := q[0][0], q[0][1]
			q = q[1:]
			for j := 0; j < 4; j++ {
				nx, ny := x+dirs[j], y+dirs[j+1]
				if nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] > 0 {
					if low <= grid[nx][ny] && grid[nx][ny] <= high {
						pq = append(pq, []int{step, grid[nx][ny], nx, ny})
					}
					grid[nx][ny] = 0
					q = append(q, [2]int{nx, ny})
				}
			}
		}
	}
	sort.Slice(pq, func(i, j int) bool {
		a, b := pq[i], pq[j]
		if a[0] != b[0] {
			return a[0] < b[0]
		}
		if a[1] != b[1] {
			return a[1] < b[1]
		}
		if a[2] != b[2] {
			return a[2] < b[2]
		}
		return a[3] < b[3]
	})
	for i := 0; i < len(pq) && i < k; i++ {
		ans = append(ans, pq[i][2:])
	}
	return
}