★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10478921.html
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
You have k lists of sorted integers in ascending order. Find the smallest range that includes at least one number from each of the k lists.
We define the range [a,b] is smaller than range [c,d] if b-a < d-c or a < c if b-a == d-c.
Example 1:
Input:[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
Output: [20,24]
Explanation:
List 1: [4, 10, 15, 24,26], 24 is in range [20,24].
List 2: [0, 9, 12, 20], 20 is in range [20,24].
List 3: [5, 18, 22, 30], 22 is in range [20,24]. Note:
- The given list may contain duplicates, so ascending order means >= here.
- 1 <=
k<= 3500 - -105 <=
value of elements<= 105. - For Java users, please note that the input type has been changed to List<List<Integer>>. And after you reset the code template, you'll see this point.
你有 k 个升序排列的整数数组。找到一个最小区间，使得 k 个列表中的每个列表至少有一个数包含在其中。
我们定义如果 b-a < d-c 或者在 b-a == d-c 时 a < c，则区间 [a,b] 比 [c,d] 小。
示例 1:
输入:[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
输出: [20,24]
解释:
列表 1：[4, 10, 15, 24, 26]，24 在区间 [20,24] 中。
列表 2：[0, 9, 12, 20]，20 在区间 [20,24] 中。
列表 3：[5, 18, 22, 30]，22 在区间 [20,24] 中。注意:
- 给定的列表可能包含重复元素，所以在这里升序表示 >= 。
- 1 <=
k<= 3500 - -105 <=
元素的值<= 105 - 对于使用Java的用户，请注意传入类型已修改为List<List<Integer>>。重置代码模板后可以看到这项改动。
344ms
1 class Solution {
2 func smallestRange(_ nums: [[Int]]) -> [Int] {
3 var point2Lists = [Int: [Int]]()
4 for i in 0..<nums.count {
5 for n in nums[i] {
6 point2Lists[n, default:[Int]()].append(i)
7 }
8 }
9
10 let kvs = point2Lists.sorted(by: {$0.0 < $1.0})
11 let k = nums.count
12 var counter = Array(repeating: 0, count: k)
13 var ret = [0, Int.max]
14 var coveredLists = 0
15 var i = 0
16 for e in 0..<kvs.count {
17 let (n, lists) = kvs[e]
18 for l in lists {
19 if counter[l] == 0 {
20 coveredLists += 1
21 }
22 counter[l] += 1
23 }
24
25 while coveredLists == k {
26 let (m, lists) = kvs[i]
27 if ret[1] - ret[0] > n - m {
28 ret = [m, n]
29 }
30 for l in lists {
31 if counter[l] == 1 {
32 coveredLists -= 1
33 }
34 counter[l] -= 1
35 }
36 i += 1
37 }
38 }
39
40 return ret
41 }
42 }
Runtime: 432 ms
Memory Usage: 21.8 MB
1 class Solution {
2 func smallestRange(_ nums: [[Int]]) -> [Int] {
3 var nums = nums
4 var res:[Int] = [Int]()
5 var v:[[Int]] = [[Int]]()
6 var m:[Int:Int] = [Int:Int]()
7 for i in 0..<nums.count
8 {
9 for num in nums[i]
10 {
11 v.append([num, i])
12 }
13 }
14 v.sort(by:{(a:[Int],b:[Int]) -> Bool in
15 if a[0] == b[0]
16 {
17 return a[1] < b[1]
18 }
19 else
20 {
21 return a[0] <= b[0]
22 }
23 })
24 var left:Int = 0
25 var n:Int = v.count
26 var k:Int = nums.count
27 var cnt:Int = 0
28 var diff:Int = Int.max
29 for right in 0..<n
30 {
31 if m[v[right][1],default:0] == 0
32 {
33 cnt += 1
34 }
35 m[v[right][1],default:0] += 1
36 while(cnt == k && left <= right)
37 {
38 if diff > v[right][0] - v[left][0]
39 {
40 diff = v[right][0] - v[left][0]
41 res = [v[left][0], v[right][0]]
42 }
43
44 m[v[left][1],default:0] -= 1
45 if m[v[left][1]] == 0
46 {
47 cnt -= 1
48 }
49 left += 1
50 }
51 }
52 return res
53 }
54 }768ms
1 /* Solution Space */
2
3 class Solution
4 {
5
6 func smallestRange( _ nums: [ [ Int ] ] ) -> [ Int ]
7 {
8
9 var traversalsHeap: BinaryHeap< ArrayTraversal > = BinaryHeap< ArrayTraversal >(
10 {
11 return ( $0.currentValue <= $1.currentValue )
12 }
13 )
14
15 var currentMax: Int = Int.min
16
17 for array in nums
18 {
19 if array.count > 0
20 {
21
22 let newTraversal: ArrayTraversal = ArrayTraversal( array )
23
24 traversalsHeap.insertElement( newTraversal )
25
26 currentMax = max( currentMax, newTraversal.currentValue )
27
28 }
29 }
30
31 guard traversalsHeap.getSize() > 0
32 else
33 {
34 return []
35 }
36
37 var minSize: Int = Int.max
38
39 var minStart: Int = -1
40 var minEnd: Int = -1
41
42 while true
43 {
44
45 let minTraversal: ArrayTraversal = traversalsHeap.deleteTopElement()!
46
47 let currentMin: Int = minTraversal.currentValue
48 let currentSize: Int = ( currentMax - currentMin )
49
50 if currentSize < minSize
51 {
52
53 minSize = currentSize
54
55 minStart = currentMin
56 minEnd = currentMax
57
58 }
59
60 if minTraversal.getNextValue()
61 {
62
63 currentMax = max( currentMax, minTraversal.currentValue )
64
65 traversalsHeap.insertElement( minTraversal )
66
67 }
68 else
69 {
70 break
71 }
72 }
73 return [ minStart, minEnd ]
74
75 }
76 }
77
78 /* Binary Heap Type */
79
80 open class BinaryHeap< Type >
81 {
82
83 /* Heap Array */
84 private var heapArray: [ Type ]
85
86 /* In Order Function */
87 private let inOrder: ( _ a: Type, _ b: Type ) -> Bool
88
89 /* Initializer */
90
91 public init( _ inOrder: @escaping ( _ a: Type, _ b: Type ) -> Bool )
92 {
93
94 self.heapArray = [ Type ]()
95
96 self.inOrder = inOrder
97
98 }
99
100 /* Get Size */
101
102 open func getSize() -> Int
103 {
104
105 return ( heapArray.count )
106
107 }
108
109 /* Get Tale */
110
111 private func getTale() -> Int
112 {
113
114 return ( heapArray.count - 1 )
115
116 }
117
118 /* Get Parent */
119
120 private func getParent( _ nodePosition: Int ) -> Int?
121 {
122
123 if nodePosition <= 0
124 {
125 return nil
126 }
127
128 let parentPosition: Int = ( ( nodePosition - 1 ) / 2 )
129
130 return parentPosition
131
132 }
133
134 /* Get Left Child */
135
136 private func getLeftChild( _ nodePosition: Int ) -> Int?
137 {
138
139 let childPosition = ( nodePosition * 2 ) + 1
140
141 if childPosition <= getTale()
142 {
143 return childPosition
144 }
145 else
146 {
147 return nil
148 }
149
150 }
151
152 /* Get Right Child */
153
154 private func getRightChild( _ nodePosition: Int ) -> Int?
155 {
156
157 let childPosition = ( nodePosition * 2 ) + 2
158
159 if childPosition <= getTale()
160 {
161 return childPosition
162 }
163 else
164 {
165 return nil
166 }
167
168 }
169
170 /* Insert Element */
171
172 open func insertElement( _ element: Type )
173 {
174
175 heapArray.append( element )
176
177 var traversal1 = getTale()
178 var goingUp = true
179
180 while goingUp
181 {
182
183 if let parent = getParent( traversal1 )
184 {
185
186 if( !inOrder( heapArray[ parent ], heapArray[ traversal1 ] ) )
187 {
188
189 let temp = heapArray[ traversal1 ]
190 heapArray[ traversal1 ] = heapArray[ parent ]
191 heapArray[ parent ] = temp
192
193 traversal1 = parent
194
195 }
196 else
197 {
198 goingUp = false
199 }
200
201 }
202 else
203 {
204 goingUp = false
205 }
206
207 }
208
209 }
210
211 /* Get Top Element */
212
213 open func getTopElement() -> Type?
214 {
215
216 if getSize() == 0
217 {
218 return nil
219 }
220 else
221 {
222 return heapArray[ 0 ]
223 }
224
225 }
226
227 /* Delete Top Element */
228
229 open func deleteTopElement() -> Type?
230 {
231
232 if getSize() == 0
233 {
234 return nil
235 }
236
237 let value = getTopElement()
238
239 heapArray[ 0 ] = heapArray[ getTale() ]
240 heapArray.removeLast()
241
242 if( getSize() > 1 )
243 {
244
245 var traversal = 0
246 var goingDown = true
247
248 while( goingDown )
249 {
250
251 var topChild: Int? = nil
252
253 if let child = getLeftChild( traversal )
254 {
255
256 topChild = child
257
258 }
259
260 if let child = getRightChild( traversal )
261 {
262
263 if( topChild == nil || !inOrder( heapArray[ topChild! ], heapArray[ child ] ) )
264 {
265
266 topChild = child
267
268 }
269
270 }
271
272 if( topChild != nil && !inOrder( heapArray[ traversal ], heapArray[ topChild! ] ) )
273 {
274
275 let temp = heapArray[ traversal ]
276 heapArray[ traversal ] = heapArray[ topChild! ]
277 heapArray[ topChild! ] = temp
278
279 traversal = topChild!
280
281 }
282 else
283 {
284 goingDown = false
285 }
286
287 }
288
289 }
290
291 return value
292
293 }
294
295 }
296
297 /* Array Traversal Type */
298
299 class ArrayTraversal
300 {
301
302 private let array: [ Int ]
303 private var currentIndex: Int
304
305 private(set) var currentValue: Int
306
307 init( _ array: [ Int ] )
308 {
309
310 self.array = array
311 self.currentIndex = 0
312
313 self.currentValue = array[ currentIndex ]
314
315 }
316
317 func getNextValue() -> Bool
318 {
319
320 if currentIndex == ( array.count - 1 )
321 {
322 return false
323 }
324
325 currentIndex += 1
326
327 currentValue = array[ currentIndex ]
328
329 return true
330
331 }
332
333 }1392ms
1 class Solution {
2 func smallestRange(_ nums: [[Int]]) -> [Int] {
3 var res = Array.init(repeating: 0, count: 2)
4
5 var m = [Int:Int]()
6 var items = [[Int]]()
7 var cnt = 0
8 for i in 0..<nums.count {
9 for n in nums[i] {
10 items.append([n, i])
11 }
12 }
13
14 items.sort(by: {$0.first! < $1.first!})
15
16 var left = 0, right = 0
17 var diff = Int.max
18 while right < items.count {
19 if m[items[right].last!] == nil || m[items[right].last!] == 0 {
20 cnt += 1
21 m[items[right].last!] = 0
22 }
23
24 m[items[right].last!] = m[items[right].last!]! + 1
25
26 while cnt == nums.count && left <= right {
27 if diff > items[right].first! - items[left].first! {
28 diff = items[right].first! - items[left].first!
29 res = [items[left].first!, items[right].first!]
30 }
31
32 m[items[left].last!] = m[items[left].last!]! - 1
33 if (m[items[left].last!] == 0) {cnt -= 1}
34 left += 1
35 }
36
37 right += 1
38 }
39
40 return res
41 }
42 }7412ms
1 class Solution {
2 func smallestRange(_ nums: [[Int]]) -> [Int] {
3 var pointers = Array(repeating: 0, count: nums.count)
4 var minDiff = Int.max
5 var output = [Int.min, Int.max]
6 while true {
7 var minIndex = 0
8 var maxValue = Int.min
9 var minValue = Int.max
10 for i in 0 ..< pointers.count {
11 let value = nums[i][pointers[i]]
12 maxValue = max(maxValue, value)
13 if value < minValue {
14 minIndex = i
15 minValue = value
16 }
17 }
18 let diff = maxValue - minValue
19 if diff < minDiff {
20 minDiff = diff
21 output[0] = minValue
22 output[1] = maxValue
23 }
24 pointers[minIndex] += 1
25 if pointers[minIndex] > nums[minIndex].count - 1 {
26 return output
27 }
28 }
29 return []
30 }
31 }
来源：oschina
链接：https://my.oschina.net/u/4381342/blog/3625791