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:

1.  Distance, defined as the length of the shortest path from the `start` (**shorter** distance has a higher rank).
2.  Price (**lower** price has a higher rank, but it must be **in the price range**).
3.  The row number (**smaller** row number has a higher rank).
4.  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 = 3
**Output:** \[\[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 = 2
**Output:** \[\[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 = 3
**Output:** \[\[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 <= 105`
*   `1 <= m * n <= 105`
*   `0 <= grid[i][j] <= 105`
*   `pricing.length == 2`
*   `2 <= low <= high <= 105`
*   `start.length == 2`
*   `0 <= row <= m - 1`
*   `0 <= col <= n - 1`
*   `grid[row][col] > 0`
*   `1 <= k <= m * n`

상점의 아이템 지도를 나타내는 'm x n' 크기의 **0 인덱스** 2D 정수 배열 '그리드'가 주어집니다. 그리드의 정수는 다음을 나타냅니다:

* `0`은 통과할 수 없는 벽을 나타냅니다.
* 1`은 자유롭게 이동할 수 있는 빈 셀을 나타냅니다.
* 다른 모든 양의 정수는 해당 셀에 있는 아이템의 가격을 나타냅니다. 이러한 아이템 셀 사이를 자유롭게 이동할 수도 있습니다.

인접한 그리드 셀 사이를 이동하는 데는 `1` 단계가 걸립니다.

또한 정수 배열인 `가격`과 `start`가 주어지는데, `가격 = [낮음, 높음]` 및 `start = [행, 열]`는 `(행, 열)` 위치에서 시작하여 `[낮음, 높음]` 범위(**포함**)에 있는 가격의 항목에만 관심을 가짐을 나타냅니다. 추가로 정수 `k`가 주어집니다.

주어진 가격 범위 내에서 가격이 **내부**인 **최고 순위** 아이템의 **위치**에 관심이 있습니다. 순위는 이러한 기준 중 다른 기준의 **첫 번째**에 의해 결정됩니다:

1.  거리: '시작점'에서 최단 경로의 길이로 정의됩니다(거리가 **짧을수록** 순위가 높습니다).
2.  가격 (**낮은** 가격이 더 높은 순위를 갖지만 **가격 범위 내**에 있어야 함).
3.  행 번호 (**작은** 행 번호가 더 높은 순위를 가짐).
4.  열 번호(**작은** 열 번호가 더 높은 순위를 가짐).

가격 범위 내에서 가장 높은 순위(가장 높은 것부터 가장 낮은 것까지)로 **소팅**된 품목을 _k개_ 반환합니다. 가격 범위 내에서 도달 가능한 아이템이 'k' 개 미만인 경우, 그 중 _**모두_를 반환합니다.

**예시 1:**

**Input:** grid = \[\[1,2,0,1\],\[1,3,0,1\],\[0,2,5,1\]\], pricing = \[2,5\], start = \[0,0\], k = 3
**Output:** \[\[0,1\],\[1,1\],\[2,1\]\]
**설명:** (0,0)에서 시작합니다.
가격 범위가 \[2,5\]인 경우 (0,1), (1,1), (2,1) 및 (2,2)에서 항목을 가져올 수 있습니다.
이러한 아이템의 순위는 다음과 같습니다:
- (0,1) 거리 1
- (1,1) 거리 2
- (2,1) 거리 3
- (2,2) 거리 4
따라서 가격 범위에서 가장 높은 순위의 3개 항목은 (0,1), (1,1), (2,1)입니다.

**예 2:**

**Input:** grid = \[\[1,2,0,1\],\[1,3,3,1\],\[0,2,5,1\]\], pricing = \[2,3\], start = \[2,3\], k = 2
**Output:** \[\[2,1\],\[1,2\]\]
**설명:** (2,3)에서 시작합니다.
가격 범위가 \[2,3\]인 경우 (0,1), (1,1), (1,2) 및 (2,1)에서 항목을 가져올 수 있습니다.
이러한 아이템의 순위는 다음과 같습니다:
- (2,1) 거리 2, 가격 2
- (1,2) 거리 2, 가격 3
- (1,1) 거리 3
- (0,1) 거리 4
따라서 가격 범위에서 가장 높은 순위의 두 항목은 (2,1) 및 (1,2)입니다.

**예 3:**

**Input:** grid = \[\[1,1,1\],\[0,0,1\],\[2,3,4\]\], pricing = \[2,3\], start = \[0,0\], k = 3
**Output:** \[\[2,1\],\[2,0\]\]
**설명:** (0,0)에서 시작합니다.
가격 범위가 \[2,3\]이면 (2,0)과 (2,1)에서 항목을 가져올 수 있습니다.
이 아이템의 순위는 다음과 같습니다:
- (2,1) 거리 5
- (2,0) 거리 6
따라서 가격 범위에서 가장 높은 순위의 두 항목은 (2,1) 및 (2,0)입니다.
k = 3이지만 가격 범위 내에서 도달 가능한 품목은 2개뿐입니다.

**제약 조건:**

* `m == grid.length`
* `n == grid[i].length`
* `1 <= m, n <= 105`
* `1 <= m * n <= 105`
* `0 <= grid[i][j] <= 105`
* `pricing.length == 2`
* `2 <= low <= high <= 105`
* `start.length == 2`
* `0 <= row <= m - 1`
* `0 <= col <= n - 1`
* `grid[row][col] > 0`
* `1 <= k <= m * n`
