Skip to content

Commit d6c66fa

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2146
No.2146.K Highest Ranked Items Within a Price Range
1 parent 15ff440 commit d6c66fa

File tree

6 files changed

+472
-6
lines changed

6 files changed

+472
-6
lines changed

‎solution/2100-2199/2146.K Highest Ranked Items Within a Price Range/README.md

Lines changed: 161 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -101,30 +101,187 @@
101101

102102
<!-- 这里可写通用的实现逻辑 -->
103103

104+
BFS。
105+
104106
<!-- tabs:start -->
105107

106108
### **Python3**
107109

108110
<!-- 这里可写当前语言的特殊实现逻辑 -->
109111

110112
```python
111-
113+
class Solution:
114+
def highestRankedKItems(self, grid: List[List[int]], pricing: List[int], start: List[int], k: int) -> List[List[int]]:
115+
m, n = len(grid), len(grid[0])
116+
row, col, low, high = start + pricing
117+
items = []
118+
if low <= grid[row][col] <= high:
119+
items.append([0, grid[row][col], row, col])
120+
q = deque([(row, col, 0)])
121+
grid[row][col] = 0
122+
while q:
123+
i, j, d = q.popleft()
124+
for a, b in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
125+
x, y = i + a, j + b
126+
if 0 <= x < m and 0 <= y < n and grid[x][y]:
127+
if low <= grid[x][y] <= high:
128+
items.append([d + 1, grid[x][y], x, y])
129+
q.append((x, y, d + 1))
130+
grid[x][y] = 0
131+
items.sort()
132+
return [item[2:] for item in items][:k]
112133
```
113134

114135
### **Java**
115136

116137
<!-- 这里可写当前语言的特殊实现逻辑 -->
117138

118139
```java
140+
class Solution {
141+
public List<List<Integer>> highestRankedKItems(int[][] grid, int[] pricing, int[] start, int k) {
142+
int m = grid.length, n = grid[0].length;
143+
int row = start[0], col = start[1];
144+
int low = pricing[0], high = pricing[1];
145+
List<int[]> items = new ArrayList<>();
146+
if (low <= grid[row][col] && grid[row][col] <= high) {
147+
items.add(new int[]{0, grid[row][col], row, col});
148+
}
149+
grid[row][col] = 0;
150+
Deque<int[]> q = new ArrayDeque<>();
151+
q.offer(new int[]{row, col, 0});
152+
int[] dirs = {-1, 0, 1, 0, -1};
153+
while (!q.isEmpty()) {
154+
int[] p = q.poll();
155+
int i = p[0], j = p[1], d = p[2];
156+
for (int l = 0; l < 4; ++l) {
157+
int x = i + dirs[l], y = j + dirs[l + 1];
158+
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) {
159+
if (low <= grid[x][y] && grid[x][y] <= high) {
160+
items.add(new int[]{d + 1, grid[x][y], x, y});
161+
}
162+
grid[x][y] = 0;
163+
q.offer(new int[]{x, y, d + 1});
164+
}
165+
}
166+
}
167+
items.sort((a, b) -> {
168+
if (a[0] != b[0]) {
169+
return a[0] - b[0];
170+
}
171+
if (a[1] != b[1]) {
172+
return a[1] - b[1];
173+
}
174+
if (a[2] != b[2]) {
175+
return a[2] - b[2];
176+
}
177+
return a[3] - b[3];
178+
});
179+
List<List<Integer>> ans = new ArrayList<>();
180+
for (int i = 0; i < items.size() && i < k; ++i) {
181+
int[] p = items.get(i);
182+
ans.add(Arrays.asList(p[2], p[3]));
183+
}
184+
return ans;
185+
}
186+
}
187+
```
119188

189+
### **C++**
190+
191+
```cpp
192+
class Solution {
193+
public:
194+
vector<vector<int>> highestRankedKItems(vector<vector<int>>& grid, vector<int>& pricing, vector<int>& start, int k) {
195+
int m = grid.size(), n = grid[0].size();
196+
int row = start[0], col = start[1];
197+
int low = pricing[0], high = pricing[1];
198+
vector<tuple<int, int, int, int>> items;
199+
if (low <= grid[row][col] && grid[row][col] <= high)
200+
items.emplace_back(0, grid[row][col], row, col);
201+
queue<tuple<int, int, int>> q;
202+
q.emplace(row, col, 0);
203+
grid[row][col] = 0;
204+
vector<int> dirs = {-1, 0, 1, 0, -1};
205+
while (!q.empty())
206+
{
207+
auto [i, j, d] = q.front();
208+
q.pop();
209+
for (int l = 0; l < 4; ++l)
210+
{
211+
int x = i + dirs[l], y = j + dirs[l + 1];
212+
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y])
213+
{
214+
if (low <= grid[x][y] && grid[x][y] <= high) items.emplace_back(d + 1, grid[x][y], x, y);
215+
grid[x][y] = 0;
216+
q.emplace(x, y, d + 1);
217+
}
218+
}
219+
}
220+
sort(items.begin(), items.end());
221+
vector<vector<int>> ans;
222+
for (int i = 0; i < items.size() && i < k; ++i)
223+
{
224+
auto [d, p, x, y] = items[i];
225+
ans.push_back({x, y});
226+
}
227+
return ans;
228+
}
229+
};
120230
```
121231
122-
### **TypeScript**
232+
### **Go**
233+
234+
```go
235+
func highestRankedKItems(grid [][]int, pricing []int, start []int, k int) [][]int {
236+
m, n := len(grid), len(grid[0])
237+
row, col := start[0], start[1]
238+
low, high := pricing[0], pricing[1]
239+
var items [][]int
240+
if low <= grid[row][col] && grid[row][col] <= high {
241+
items = append(items, []int{0, grid[row][col], row, col})
242+
}
243+
q := [][]int{{row, col, 0}}
244+
grid[row][col] = 0
245+
dirs := []int{-1, 0, 1, 0, -1}
246+
for len(q) > 0 {
247+
p := q[0]
248+
q = q[1:]
249+
i, j, d := p[0], p[1], p[2]
250+
for l := 0; l < 4; l++ {
251+
x, y := i+dirs[l], j+dirs[l+1]
252+
if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0 {
253+
if low <= grid[x][y] && grid[x][y] <= high {
254+
items = append(items, []int{d + 1, grid[x][y], x, y})
255+
}
256+
grid[x][y] = 0
257+
q = append(q, []int{x, y, d + 1})
258+
}
259+
}
260+
}
261+
sort.Slice(items, func(i, j int) bool {
262+
a, b := items[i], items[j]
263+
if a[0] != b[0] {
264+
return a[0] < b[0]
265+
}
266+
if a[1] != b[1] {
267+
return a[1] < b[1]
268+
}
269+
if a[2] != b[2] {
270+
return a[2] < b[2]
271+
}
272+
return a[3] < b[3]
273+
})
274+
var ans [][]int
275+
for i := 0; i < len(items) && i < k; i++ {
276+
ans = append(ans, items[i][2:])
277+
}
278+
return ans
279+
}
280+
```
123281

124-
<!-- 这里可写当前语言的特殊实现逻辑 -->
282+
### **TypeScript**
125283

126284
```ts
127-
128285
```
129286

130287
### **...**

‎solution/2100-2199/2146.K Highest Ranked Items Within a Price Range/README_EN.md

Lines changed: 161 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -92,24 +92,183 @@ Note that k = 3 but there are only 2 reachable items within the price range.
9292

9393
## Solutions
9494

95+
BFS.
96+
9597
<!-- tabs:start -->
9698

9799
### **Python3**
98100

99101
```python
100-
102+
class Solution:
103+
def highestRankedKItems(self, grid: List[List[int]], pricing: List[int], start: List[int], k: int) -> List[List[int]]:
104+
m, n = len(grid), len(grid[0])
105+
row, col, low, high = start + pricing
106+
items = []
107+
if low <= grid[row][col] <= high:
108+
items.append([0, grid[row][col], row, col])
109+
q = deque([(row, col, 0)])
110+
grid[row][col] = 0
111+
while q:
112+
i, j, d = q.popleft()
113+
for a, b in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
114+
x, y = i + a, j + b
115+
if 0 <= x < m and 0 <= y < n and grid[x][y]:
116+
if low <= grid[x][y] <= high:
117+
items.append([d + 1, grid[x][y], x, y])
118+
q.append((x, y, d + 1))
119+
grid[x][y] = 0
120+
items.sort()
121+
return [item[2:] for item in items][:k]
101122
```
102123

103124
### **Java**
104125

105126
```java
127+
class Solution {
128+
public List<List<Integer>> highestRankedKItems(int[][] grid, int[] pricing, int[] start, int k) {
129+
int m = grid.length, n = grid[0].length;
130+
int row = start[0], col = start[1];
131+
int low = pricing[0], high = pricing[1];
132+
List<int[]> items = new ArrayList<>();
133+
if (low <= grid[row][col] && grid[row][col] <= high) {
134+
items.add(new int[]{0, grid[row][col], row, col});
135+
}
136+
grid[row][col] = 0;
137+
Deque<int[]> q = new ArrayDeque<>();
138+
q.offer(new int[]{row, col, 0});
139+
int[] dirs = {-1, 0, 1, 0, -1};
140+
while (!q.isEmpty()) {
141+
int[] p = q.poll();
142+
int i = p[0], j = p[1], d = p[2];
143+
for (int l = 0; l < 4; ++l) {
144+
int x = i + dirs[l], y = j + dirs[l + 1];
145+
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0) {
146+
if (low <= grid[x][y] && grid[x][y] <= high) {
147+
items.add(new int[]{d + 1, grid[x][y], x, y});
148+
}
149+
grid[x][y] = 0;
150+
q.offer(new int[]{x, y, d + 1});
151+
}
152+
}
153+
}
154+
items.sort((a, b) -> {
155+
if (a[0] != b[0]) {
156+
return a[0] - b[0];
157+
}
158+
if (a[1] != b[1]) {
159+
return a[1] - b[1];
160+
}
161+
if (a[2] != b[2]) {
162+
return a[2] - b[2];
163+
}
164+
return a[3] - b[3];
165+
});
166+
List<List<Integer>> ans = new ArrayList<>();
167+
for (int i = 0; i < items.size() && i < k; ++i) {
168+
int[] p = items.get(i);
169+
ans.add(Arrays.asList(p[2], p[3]));
170+
}
171+
return ans;
172+
}
173+
}
174+
```
175+
176+
### **C++**
106177

178+
```cpp
179+
class Solution {
180+
public:
181+
vector<vector<int>> highestRankedKItems(vector<vector<int>>& grid, vector<int>& pricing, vector<int>& start, int k) {
182+
int m = grid.size(), n = grid[0].size();
183+
int row = start[0], col = start[1];
184+
int low = pricing[0], high = pricing[1];
185+
vector<tuple<int, int, int, int>> items;
186+
if (low <= grid[row][col] && grid[row][col] <= high)
187+
items.emplace_back(0, grid[row][col], row, col);
188+
queue<tuple<int, int, int>> q;
189+
q.emplace(row, col, 0);
190+
grid[row][col] = 0;
191+
vector<int> dirs = {-1, 0, 1, 0, -1};
192+
while (!q.empty())
193+
{
194+
auto [i, j, d] = q.front();
195+
q.pop();
196+
for (int l = 0; l < 4; ++l)
197+
{
198+
int x = i + dirs[l], y = j + dirs[l + 1];
199+
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y])
200+
{
201+
if (low <= grid[x][y] && grid[x][y] <= high) items.emplace_back(d + 1, grid[x][y], x, y);
202+
grid[x][y] = 0;
203+
q.emplace(x, y, d + 1);
204+
}
205+
}
206+
}
207+
sort(items.begin(), items.end());
208+
vector<vector<int>> ans;
209+
for (int i = 0; i < items.size() && i < k; ++i)
210+
{
211+
auto [d, p, x, y] = items[i];
212+
ans.push_back({x, y});
213+
}
214+
return ans;
215+
}
216+
};
217+
```
218+
219+
### **Go**
220+
221+
```go
222+
func highestRankedKItems(grid [][]int, pricing []int, start []int, k int) [][]int {
223+
m, n := len(grid), len(grid[0])
224+
row, col := start[0], start[1]
225+
low, high := pricing[0], pricing[1]
226+
var items [][]int
227+
if low <= grid[row][col] && grid[row][col] <= high {
228+
items = append(items, []int{0, grid[row][col], row, col})
229+
}
230+
q := [][]int{{row, col, 0}}
231+
grid[row][col] = 0
232+
dirs := []int{-1, 0, 1, 0, -1}
233+
for len(q) > 0 {
234+
p := q[0]
235+
q = q[1:]
236+
i, j, d := p[0], p[1], p[2]
237+
for l := 0; l < 4; l++ {
238+
x, y := i+dirs[l], j+dirs[l+1]
239+
if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] > 0 {
240+
if low <= grid[x][y] && grid[x][y] <= high {
241+
items = append(items, []int{d + 1, grid[x][y], x, y})
242+
}
243+
grid[x][y] = 0
244+
q = append(q, []int{x, y, d + 1})
245+
}
246+
}
247+
}
248+
sort.Slice(items, func(i, j int) bool {
249+
a, b := items[i], items[j]
250+
if a[0] != b[0] {
251+
return a[0] < b[0]
252+
}
253+
if a[1] != b[1] {
254+
return a[1] < b[1]
255+
}
256+
if a[2] != b[2] {
257+
return a[2] < b[2]
258+
}
259+
return a[3] < b[3]
260+
})
261+
var ans [][]int
262+
for i := 0; i < len(items) && i < k; i++ {
263+
ans = append(ans, items[i][2:])
264+
}
265+
return ans
266+
}
107267
```
108268

109269
### **TypeScript**
110270

111271
```ts
112-
113272
```
114273

115274
### **...**

0 commit comments

Comments
 (0)