Skip to content

Commit 813b3ef

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0632
No.0632.Smallest Range Covering Elements from K Lists
1 parent d9237bc commit 813b3ef

File tree

6 files changed

+403
-2
lines changed

6 files changed

+403
-2
lines changed

‎solution/0600-0699/0632.Smallest Range Covering Elements from K Lists/README.md

+144-1
Original file line numberDiff line numberDiff line change
@@ -48,22 +48,165 @@
4848

4949
<!-- 这里可写通用的实现逻辑 -->
5050

51+
**方法一：排序 + 滑动窗口**
52+
53+
将每个数字 $v$ 及其所在的组 $i$，构成数据项 $(v, i)$，存放在一个新的列表或者数组中，记为 `t`。
54+
55+
对 `t` 按照数字的大小进行排序（类似于将多个有序数组合并成一个新的有序数组）。
56+
57+
然后遍历 `t` 中每个数据项，只看其中数字所在的组，用哈希表记录滑动窗口内的数字出现的组，如果组数为 $k$，说明当前窗口满足题目要求，此时算出窗口的起始和结束位置，更新答案。
58+
59+
时间复杂度 $O(n\log n)$。其中 $n$ 是所有数字的总数。
60+
5161
<!-- tabs:start -->
5262

5363
### **Python3**
5464

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

5767
```python
58-
68+
class Solution:
69+
def smallestRange(self, nums: List[List[int]]) -> List[int]:
70+
t = [(x, i) for i, v in enumerate(nums) for x in v]
71+
t.sort()
72+
cnt = Counter()
73+
ans = [-inf, inf]
74+
j = 0
75+
for i, (b, v) in enumerate(t):
76+
cnt[v] += 1
77+
while len(cnt) == len(nums):
78+
a = t[j][0]
79+
x = b - a - (ans[1] - ans[0])
80+
if x < 0 or (x == 0 and a < ans[0]):
81+
ans = [a, b]
82+
w = t[j][1]
83+
cnt[w] -= 1
84+
if cnt[w] == 0:
85+
cnt.pop(w)
86+
j += 1
87+
return ans
5988
```
6089

6190
### **Java**
6291

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

6594
```java
95+
class Solution {
96+
public int[] smallestRange(List<List<Integer>> nums) {
97+
int n = 0;
98+
for (var v : nums) {
99+
n += v.size();
100+
}
101+
int[][] t = new int[n][2];
102+
int k = nums.size();
103+
for (int i = 0, j = 0; i < k; ++i) {
104+
for (int x : nums.get(i)) {
105+
t[j++] = new int[] {x, i};
106+
}
107+
}
108+
Arrays.sort(t, (a, b) -> a[0] - b[0]);
109+
int j = 0;
110+
Map<Integer, Integer> cnt = new HashMap<>();
111+
int[] ans = new int[] {-1000000, 1000000};
112+
for (int[] e : t) {
113+
int b = e[0];
114+
int v = e[1];
115+
cnt.put(v, cnt.getOrDefault(v, 0) + 1);
116+
while (cnt.size() == k) {
117+
int a = t[j][0];
118+
int w = t[j][1];
119+
int x = b - a - (ans[1] - ans[0]);
120+
if (x < 0 || (x == 0 && a < ans[0])) {
121+
ans[0] = a;
122+
ans[1] = b;
123+
}
124+
cnt.put(w, cnt.get(w) - 1);
125+
if (cnt.get(w) == 0) {
126+
cnt.remove(w);
127+
}
128+
++j;
129+
}
130+
}
131+
return ans;
132+
}
133+
}
134+
```
135+
136+
### **C++**
137+
138+
```cpp
139+
class Solution {
140+
public:
141+
vector<int> smallestRange(vector<vector<int>>& nums) {
142+
int n = 0;
143+
for (auto& v : nums) n += v.size();
144+
vector<pair<int, int>> t(n);
145+
int k = nums.size();
146+
for (int i = 0, j = 0; i < k; ++i) {
147+
for (int v : nums[i]) {
148+
t[j++] = {v, i};
149+
}
150+
}
151+
sort(t.begin(), t.end());
152+
int j = 0;
153+
unordered_map<int, int> cnt;
154+
vector<int> ans = {-1000000, 1000000};
155+
for (int i = 0; i < n; ++i) {
156+
int b = t[i].first;
157+
int v = t[i].second;
158+
++cnt[v];
159+
while (cnt.size() == k) {
160+
int a = t[j].first;
161+
int w = t[j].second;
162+
int x = b - a - (ans[1] - ans[0]);
163+
if (x < 0 || (x == 0 && a < ans[0])) {
164+
ans[0] = a;
165+
ans[1] = b;
166+
}
167+
if (--cnt[w] == 0) {
168+
cnt.erase(w);
169+
}
170+
++j;
171+
}
172+
}
173+
return ans;
174+
}
175+
};
176+
```
66177
178+
### **Go**
179+
180+
```go
181+
func smallestRange(nums [][]int) []int {
182+
t := [][]int{}
183+
for i, x := range nums {
184+
for _, v := range x {
185+
t = append(t, []int{v, i})
186+
}
187+
}
188+
sort.Slice(t, func(i, j int) bool { return t[i][0] < t[j][0] })
189+
ans := []int{-1000000, 1000000}
190+
j := 0
191+
cnt := map[int]int{}
192+
for _, x := range t {
193+
b, v := x[0], x[1]
194+
cnt[v]++
195+
for len(cnt) == len(nums) {
196+
a, w := t[j][0], t[j][1]
197+
x := b - a - (ans[1] - ans[0])
198+
if x < 0 || (x == 0 && a < ans[0]) {
199+
ans[0], ans[1] = a, b
200+
}
201+
cnt[w]--
202+
if cnt[w] == 0 {
203+
delete(cnt, w)
204+
}
205+
j++
206+
}
207+
}
208+
return ans
209+
}
67210
```
68211

69212
### **...**

‎solution/0600-0699/0632.Smallest Range Covering Elements from K Lists/README_EN.md

+134-1
Original file line numberDiff line numberDiff line change
@@ -45,13 +45,146 @@ List 3: [5, 18, 22, 30], 22 is in range [20,24].
4545
### **Python3**
4646

4747
```python
48-
48+
class Solution:
49+
def smallestRange(self, nums: List[List[int]]) -> List[int]:
50+
t = [(x, i) for i, v in enumerate(nums) for x in v]
51+
t.sort()
52+
cnt = Counter()
53+
ans = [-inf, inf]
54+
j = 0
55+
for b, v in t:
56+
cnt[v] += 1
57+
while len(cnt) == len(nums):
58+
a = t[j][0]
59+
x = b - a - (ans[1] - ans[0])
60+
if x < 0 or (x == 0 and a < ans[0]):
61+
ans = [a, b]
62+
w = t[j][1]
63+
cnt[w] -= 1
64+
if cnt[w] == 0:
65+
cnt.pop(w)
66+
j += 1
67+
return ans
4968
```
5069

5170
### **Java**
5271

5372
```java
73+
class Solution {
74+
public int[] smallestRange(List<List<Integer>> nums) {
75+
int n = 0;
76+
for (var v : nums) {
77+
n += v.size();
78+
}
79+
int[][] t = new int[n][2];
80+
int k = nums.size();
81+
for (int i = 0, j = 0; i < k; ++i) {
82+
for (int x : nums.get(i)) {
83+
t[j++] = new int[] {x, i};
84+
}
85+
}
86+
Arrays.sort(t, (a, b) -> a[0] - b[0]);
87+
int j = 0;
88+
Map<Integer, Integer> cnt = new HashMap<>();
89+
int[] ans = new int[] {-1000000, 1000000};
90+
for (int[] e : t) {
91+
int b = e[0];
92+
int v = e[1];
93+
cnt.put(v, cnt.getOrDefault(v, 0) + 1);
94+
while (cnt.size() == k) {
95+
int a = t[j][0];
96+
int w = t[j][1];
97+
int x = b - a - (ans[1] - ans[0]);
98+
if (x < 0 || (x == 0 && a < ans[0])) {
99+
ans[0] = a;
100+
ans[1] = b;
101+
}
102+
cnt.put(w, cnt.get(w) - 1);
103+
if (cnt.get(w) == 0) {
104+
cnt.remove(w);
105+
}
106+
++j;
107+
}
108+
}
109+
return ans;
110+
}
111+
}
112+
```
113+
114+
### **C++**
115+
116+
```cpp
117+
class Solution {
118+
public:
119+
vector<int> smallestRange(vector<vector<int>>& nums) {
120+
int n = 0;
121+
for (auto& v : nums) n += v.size();
122+
vector<pair<int, int>> t(n);
123+
int k = nums.size();
124+
for (int i = 0, j = 0; i < k; ++i) {
125+
for (int v : nums[i]) {
126+
t[j++] = {v, i};
127+
}
128+
}
129+
sort(t.begin(), t.end());
130+
int j = 0;
131+
unordered_map<int, int> cnt;
132+
vector<int> ans = {-1000000, 1000000};
133+
for (int i = 0; i < n; ++i) {
134+
int b = t[i].first;
135+
int v = t[i].second;
136+
++cnt[v];
137+
while (cnt.size() == k) {
138+
int a = t[j].first;
139+
int w = t[j].second;
140+
int x = b - a - (ans[1] - ans[0]);
141+
if (x < 0 || (x == 0 && a < ans[0])) {
142+
ans[0] = a;
143+
ans[1] = b;
144+
}
145+
if (--cnt[w] == 0) {
146+
cnt.erase(w);
147+
}
148+
++j;
149+
}
150+
}
151+
return ans;
152+
}
153+
};
154+
```
54155
156+
### **Go**
157+
158+
```go
159+
func smallestRange(nums [][]int) []int {
160+
t := [][]int{}
161+
for i, x := range nums {
162+
for _, v := range x {
163+
t = append(t, []int{v, i})
164+
}
165+
}
166+
sort.Slice(t, func(i, j int) bool { return t[i][0] < t[j][0] })
167+
ans := []int{-1000000, 1000000}
168+
j := 0
169+
cnt := map[int]int{}
170+
for _, x := range t {
171+
b, v := x[0], x[1]
172+
cnt[v]++
173+
for len(cnt) == len(nums) {
174+
a, w := t[j][0], t[j][1]
175+
x := b - a - (ans[1] - ans[0])
176+
if x < 0 || (x == 0 && a < ans[0]) {
177+
ans[0], ans[1] = a, b
178+
}
179+
cnt[w]--
180+
if cnt[w] == 0 {
181+
delete(cnt, w)
182+
}
183+
j++
184+
}
185+
}
186+
return ans
187+
}
55188
```
56189

57190
### **...**

‎solution/0600-0699/0632.Smallest Range Covering Elements from K Lists/Solution.cpp

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
class Solution {
2+
public:
3+
vector<int> smallestRange(vector<vector<int>>& nums) {
4+
int n = 0;
5+
for (auto& v : nums) n += v.size();
6+
vector<pair<int, int>> t(n);
7+
int k = nums.size();
8+
for (int i = 0, j = 0; i < k; ++i) {
9+
for (int v : nums[i]) {
10+
t[j++] = {v, i};
11+
}
12+
}
13+
sort(t.begin(), t.end());
14+
int j = 0;
15+
unordered_map<int, int> cnt;
16+
vector<int> ans = {-1000000, 1000000};
17+
for (int i = 0; i < n; ++i) {
18+
int b = t[i].first;
19+
int v = t[i].second;
20+
++cnt[v];
21+
while (cnt.size() == k) {
22+
int a = t[j].first;
23+
int w = t[j].second;
24+
int x = b - a - (ans[1] - ans[0]);
25+
if (x < 0 || (x == 0 && a < ans[0])) {
26+
ans[0] = a;
27+
ans[1] = b;
28+
}
29+
if (--cnt[w] == 0) {
30+
cnt.erase(w);
31+
}
32+
++j;
33+
}
34+
}
35+
return ans;
36+
}
37+
};

‎solution/0600-0699/0632.Smallest Range Covering Elements from K Lists/Solution.go

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func smallestRange(nums [][]int) []int {
2+
t := [][]int{}
3+
for i, x := range nums {
4+
for _, v := range x {
5+
t = append(t, []int{v, i})
6+
}
7+
}
8+
sort.Slice(t, func(i, j int) bool { return t[i][0] < t[j][0] })
9+
ans := []int{-1000000, 1000000}
10+
j := 0
11+
cnt := map[int]int{}
12+
for _, x := range t {
13+
b, v := x[0], x[1]
14+
cnt[v]++
15+
for len(cnt) == len(nums) {
16+
a, w := t[j][0], t[j][1]
17+
x := b - a - (ans[1] - ans[0])
18+
if x < 0 || (x == 0 && a < ans[0]) {
19+
ans[0], ans[1] = a, b
20+
}
21+
cnt[w]--
22+
if cnt[w] == 0 {
23+
delete(cnt, w)
24+
}
25+
j++
26+
}
27+
}
28+
return ans
29+
}

0 commit comments

Comments
 (0)