logo

TechCodeview

k개의 정렬된 목록에 있는 요소의 최소 범위

GfG Practice에서 사용해 보세요. ' title=

2차원 정수 배열이 주어지면 도착[][] 질서의 k * n 각 행의 위치 정렬됨 오름차순으로. 당신의 임무는 각 요소에서 최소한 하나의 요소를 포함하는 가장 작은 범위를 찾는 것입니다.  케이  기울기. 해당 범위가 두 개 이상 발견되면 첫 번째 범위를 반환합니다.

예:  



입력: 도착[][] = [[ 4 7 9 12 15 ]
[0 8 10 14 20]
[6 12 16 30 50 ]]
산출: 6 8
설명: 가장 작은 범위는 첫 번째 목록의 숫자 7, 두 번째 목록의 8, 세 번째 목록의 6으로 구성됩니다.

입력: arr[][] = [[ 2 4 ]
[1 7]
[20 40]]
산출: 4 20
설명: [4 20] 범위에는 세 배열 모두의 요소를 포함하는 4 7 20이 포함됩니다.

목차



[순진한 접근 방식] - K 포인터 사용 - O(n k^2) 시간 및 O(k) 공간

아이디어는 인덱스 0에서 시작하는 각 목록에 대해 k개의 포인터를 하나씩 유지하는 것입니다. 각 단계에서 최소 및 최대 현재 K개 요소를 사용하여 범위를 형성합니다. 에게 범위를 최소화하다 우리는 해야 한다 최소값을 높이세요 왜냐하면 우리는 최대값을 줄일 수 없기 때문입니다(모든 포인터는 0에서 시작합니다). 따라서 현재 최소값 범위를 업데이트합니다. 하나의 목록이 소진될 때까지 반복합니다.

단계별 구현:

  • 포인터 목록 만들기 인덱스 0에서 시작하는 각 입력 목록마다 하나씩.
  • 과정을 반복하세요 포인터 중 하나가 목록 끝에 도달할 때까지.
  • 각 단계에서 현재 요소를 선택하세요 모든 포인터가 가리킨다.
  • 찾기 최소 및 최대 그 요소들 중.
  • 범위 계산 최소값과 최대값을 사용합니다.
  • 이 범위가 더 작은 경우 이전 최고의 답변보다 업데이트하십시오.
  • 포인터를 앞으로 이동 최소 요소가 있는 목록의 목록입니다.
  • 목록이 소진되면 중지 찾은 최상의 범위를 반환합니다.
C++ 
// C++ program to find the smallest range // that includes at least one element from // each of the k sorted lists using k pointers #include    #include  #include  using namespace std; vector<int> findSmallestRange(vector<vector<int>>& arr) {    int k = arr.size();   int n = arr[0].size();   // Pointers for each of the k rows  vector<int> ptr(k 0);  int minRange = INT_MAX;  int start = -1 end = -1;  while (true) {  int minVal = INT_MAX;  int maxVal = INT_MIN;  int minRow = -1;  // Traverse all k rows to get current min and max  for (int i = 0; i < k; i++) {  // If any list is exhausted stop the loop  if (ptr[i] == n) {  return {start end};  }  // Track min value and its row index  if (arr[i][ptr[i]] < minVal) {  minVal = arr[i][ptr[i]];  minRow = i;  }  // Track current max value  if (arr[i][ptr[i]] > maxVal) {  maxVal = arr[i][ptr[i]];  }  }  // Update the result range if a   // smaller range is found  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  start = minVal;  end = maxVal;  }  // Move the pointer of the   // row with minimum value  ptr[minRow]++;  }  return {start end}; } int main() {  vector<vector<int>> arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  vector<int> res = findSmallestRange(arr);  cout << res[0] << ' ' << res[1];  return 0; }
Java 
// Java program to find the smallest range import java.util.*; class GfG{  static ArrayList<Integer> findSmallestRange(int[][] arr) {  int k = arr.length;  int n = arr[0].length;  // Pointers for each of the k rows  int[] ptr = new int[k];  int minRange = Integer.MAX_VALUE;  int start = -1 end = -1;  while (true) {  int minVal = Integer.MAX_VALUE;  int maxVal = Integer.MIN_VALUE;  int minRow = -1;  // Traverse all k rows to get current min and max  for (int i = 0; i < k; i++) {  // If any list is exhausted stop the loop  if (ptr[i] == n) {  ArrayList<Integer> result = new ArrayList<>();  result.add(start);  result.add(end);  return result;  }  // Track min value and its row index  if (arr[i][ptr[i]] < minVal) {  minVal = arr[i][ptr[i]];  minRow = i;  }  // Track current max value  if (arr[i][ptr[i]] > maxVal) {  maxVal = arr[i][ptr[i]];  }  }  // Update the result range if a smaller range is found  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  start = minVal;  end = maxVal;  }  // Move the pointer of the row with minimum value  ptr[minRow]++;  }  }  public static void main(String[] args) {  int[][] arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  ArrayList<Integer> res = findSmallestRange(arr);  System.out.println(res.get(0) + ' ' + res.get(1));  } }
Python 
# Python program to find the smallest range def findSmallestRange(arr): k = len(arr) n = len(arr[0]) # Pointers for each of the k rows ptr = [0] * k min_range = float('inf') start = -1 end = -1 while True: min_val = float('inf') max_val = float('-inf') min_row = -1 # Traverse all k rows to get current min and max for i in range(k): # If any list is exhausted stop the loop if ptr[i] == n: return [start end] # Track min value and its row index if arr[i][ptr[i]] < min_val: min_val = arr[i][ptr[i]] min_row = i # Track current max value if arr[i][ptr[i]] > max_val: max_val = arr[i][ptr[i]] # Update the result range if a smaller range is found if max_val - min_val < min_range: min_range = max_val - min_val start = min_val end = max_val # Move the pointer of the row with minimum value ptr[min_row] += 1 if __name__ == '__main__': arr = [ [4 7 9 12 15] [0 8 10 14 20] [6 12 16 30 50] ] res = findSmallestRange(arr) print(res[0] res[1])
C# 
using System; using System.Collections.Generic; class GfG{  static List<int> findSmallestRange(int[] arr) {  int k = arr.GetLength(0);  int n = arr.GetLength(1);  // Pointers for each of the k rows  int[] ptr = new int[k];   int minRange = int.MaxValue;  int start = -1 end = -1;  while (true) {  int minVal = int.MaxValue;  int maxVal = int.MinValue;  int minRow = -1;  // Traverse all k rows to get current min and max  for (int i = 0; i < k; i++) {  // If any list is exhausted stop the loop  if (ptr[i] == n) {  return new List<int> { start end };  }  int current = arr[i ptr[i]];  if (current < minVal) {  minVal = current;  minRow = i;  }  if (current > maxVal) {  maxVal = current;  }  }  // Update the result range if a smaller range is found  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  start = minVal;  end = maxVal;  }  // Move the pointer of the row with minimum value  ptr[minRow]++;  }  }  public static void Main(string[] args) {  int[] arr = {  { 4 7 9 12 15 }  { 0 8 10 14 20 }  { 6 12 16 30 50 }  };  List<int> res = findSmallestRange(arr);  Console.WriteLine(res[0] + ' ' + res[1]);  } }
JavaScript 
// JavaScript program to find the smallest range function findSmallestRange(arr) {  let k = arr.length;  let n = arr[0].length;  // Pointers for each of the k rows  let ptr = new Array(k).fill(0);  let minRange = Infinity;  let start = -1 end = -1;  while (true) {  let minVal = Infinity;  let maxVal = -Infinity;  let minRow = -1;  // Traverse all k rows to get current min and max  for (let i = 0; i < k; i++) {  // If any list is exhausted stop the loop  if (ptr[i] === n) {  return [start end];  }  // Track min value and its row index  if (arr[i][ptr[i]] < minVal) {  minVal = arr[i][ptr[i]];  minRow = i;  }  // Track current max value  if (arr[i][ptr[i]] > maxVal) {  maxVal = arr[i][ptr[i]];  }  }  // Update the result range if a smaller range is found  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  start = minVal;  end = maxVal;  }  // Move the pointer of the row with minimum value  ptr[minRow]++;  } } const arr = [  [4 7 9 12 15]  [0 8 10 14 20]  [6 12 16 30 50] ]; const res = findSmallestRange(arr); console.log(res[0] + ' ' + res[1]);

산출 
6 8

[더 나은 접근 방식] 두 포인터 사용 - O(n*k log (n*k)) 시간 및 O(n*k) 공간

아이디어는 입력 목록의 모든 요소를 ​​병합하고 정렬한 목록에 대한 슬라이딩 윈도우 문제로 변환하여 가장 작은 범위 문제를 찾는 것입니다. 각 요소는 원본 목록 색인과 함께 저장되어 소스를 추적합니다. 두 포인터 값을 기준으로 결합된 목록을 정렬한 후(left그리고right)는 목록을 통해 이동하는 창을 정의하는 데 사용됩니다. 창이 확장됨에 따라 빈도 맵은 얼마나 많은 고유 목록이 표시되는지 추적합니다. 창에 모든 목록의 숫자가 하나 이상 포함되어 있으면 알고리즘은 더 작은 유효 범위를 찾기 위해 왼쪽에서 숫자를 축소하려고 시도합니다. 이 과정에서 발견된 가장 작은 범위가 결과로 반환됩니다.



C++ 
#include    using namespace std; vector<int> findSmallestRange(vector<vector<int>>& arr) {    int k = arr.size();   // Stores the current index for each list  vector<int> pointers(k 0);  // Stores the current smallest range  vector<int> smallestRange = {0 INT_MAX};  while (true) {  int currentMin = INT_MAX currentMax = INT_MIN;  int minListIndex = -1;  // Find the minimum and maximum among current elements of all lists  for (int i = 0; i < k; i++) {  int value = arr[i][pointers[i]];  if (value < currentMin) {  currentMin = value;  minListIndex = i;  }  if (value > currentMax) {  currentMax = value;  }  }  // Update the smallest range if this one is smaller  if (currentMax - currentMin < smallestRange[1] - smallestRange[0]) {  smallestRange[0] = currentMin;  smallestRange[1] = currentMax;  }  // Move the pointer in the list that had the minimum value  pointers[minListIndex]++;  // If that list is exhausted break the loop  if (pointers[minListIndex] == arr[minListIndex].size()) break;  }  return smallestRange; } // Driver code int main() {  vector<vector<int>> arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  vector<int> result = findSmallestRange(arr);  cout << result[0] << ' ' << result[1];  return 0; }
Java 
import java.util.*; class GfG {  // Function to find the smallest range  public static ArrayList<Integer> findSmallestRange(int[][] arr) {  int k = arr.length; // Number of lists  // Stores the current index for each list  int[] pointers = new int[k];  // Stores the current smallest range  ArrayList<Integer> smallestRange = new ArrayList<>  (Arrays.asList(0 Integer.MAX_VALUE));  // Continue the loop until one list is exhausted  while (true) {  int currentMin = Integer.MAX_VALUE currentMax = Integer.MIN_VALUE;  int minListIndex = -1;  // Find the minimum and maximum among current elements of all lists  for (int i = 0; i < k; i++) {  int value = arr[i][pointers[i]];  // Update the current minimum  if (value < currentMin) {  currentMin = value;  minListIndex = i;  }  // Update the current maximum  if (value > currentMax) {  currentMax = value;  }  }  // Update the smallest range if this one is smaller  if (currentMax - currentMin < smallestRange.get(1) - smallestRange.get(0)) {  smallestRange.set(0 currentMin);  smallestRange.set(1 currentMax);  }  // Move the pointer in the list that had the minimum value  pointers[minListIndex]++;  // If that list is exhausted break the loop  if (pointers[minListIndex] == arr[minListIndex].length) break;  }  return smallestRange; // Return the result as ArrayList  }  // Driver code  public static void main(String[] args) {  int[][] arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  ArrayList<Integer> result = findSmallestRange(arr);  System.out.println(result.get(0) + ' ' + result.get(1));  } }
Python 
def findSmallestRange(arr): k = len(arr) # Number of lists # Stores the current index for each list pointers = [0] * k # Stores the current smallest range smallestRange = [0 float('inf')] # Continue the loop until one list is exhausted while True: currentMin = float('inf') currentMax = -float('inf') minListIndex = -1 # Find the minimum and maximum among current elements of all lists for i in range(k): value = arr[i][pointers[i]] # Update the current minimum if value < currentMin: currentMin = value minListIndex = i # Update the current maximum if value > currentMax: currentMax = value # Update the smallest range if this one is smaller if currentMax - currentMin < smallestRange[1] - smallestRange[0]: smallestRange[0] = currentMin smallestRange[1] = currentMax # Move the pointer in the list that had the minimum value pointers[minListIndex] += 1 # If that list is exhausted break the loop if pointers[minListIndex] == len(arr[minListIndex]): break return smallestRange # Return the result as a list # Driver code if __name__ == '__main__': arr = [ [4 7 9 12 15] [0 8 10 14 20] [6 12 16 30 50] ] result = findSmallestRange(arr) print(result[0] result[1])
C# 
using System; using System.Collections.Generic; class GfG{  // Function to find the smallest range  public static List<int> findSmallestRange(int[] arr) {  int k = arr.GetLength(0); // Number of lists (rows)  // Stores the current index for each list (row)  int[] pointers = new int[k];  // Stores the current smallest range  List<int> smallestRange = new List<int> { 0 int.MaxValue };  // Continue the loop until one list is exhausted  while (true) {  int currentMin = int.MaxValue currentMax = int.MinValue;  int minListIndex = -1;  // Find the minimum and maximum among current elements   // of all lists  for (int i = 0; i < k; i++) {  int value = arr[i pointers[i]];  // Update the current minimum  if (value < currentMin) {  currentMin = value;  minListIndex = i;  }  // Update the current maximum  if (value > currentMax) {  currentMax = value;  }  }  // Update the smallest range if this one is smaller  if (currentMax - currentMin < smallestRange[1] - smallestRange[0]) {  smallestRange[0] = currentMin;  smallestRange[1] = currentMax;  }  // Move the pointer in the list that had the minimum value  pointers[minListIndex]++;  // If that list is exhausted break the loop  if (pointers[minListIndex] == arr.GetLength(1)) break;  }  return smallestRange; // Return the result as List    }  // Driver code  public static void Main(string[] args) {  int[] arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  List<int> result = findSmallestRange(arr);  Console.WriteLine(result[0] + ' ' + result[1]);  } }
JavaScript 
function findSmallestRange(arr) {  const k = arr.length; // Number of lists  // Stores the current index for each list  let pointers = new Array(k).fill(0);  // Stores the current smallest range  let smallestRange = [0 Number.MAX_VALUE];  // Continue the loop until one list is exhausted  while (true) {  let currentMin = Number.MAX_VALUE currentMax = -Number.MAX_VALUE;  let minListIndex = -1;  // Find the minimum and maximum among current elements of all lists  for (let i = 0; i < k; i++) {  const value = arr[i][pointers[i]];  // Update the current minimum  if (value < currentMin) {  currentMin = value;  minListIndex = i;  }  // Update the current maximum  if (value > currentMax) {  currentMax = value;  }  }  // Update the smallest range if this one is smaller  if (currentMax - currentMin < smallestRange[1] - smallestRange[0]) {  smallestRange[0] = currentMin;  smallestRange[1] = currentMax;  }  // Move the pointer in the list that had the minimum value  pointers[minListIndex]++;  // If that list is exhausted break the loop  if (pointers[minListIndex] === arr[minListIndex].length) break;  }  return smallestRange; // Return the result as an array } // Driver code const arr = [  [4 7 9 12 15]  [0 8 10 14 20]  [6 12 16 30 50] ]; const result = findSmallestRange(arr); console.log(result[0] result[1]);

산출 
6 8

[효율적인 접근 방식] - 최소 힙 사용 - O(n k Log k) 시간 및 O(k) 공간

최소 힙 선형 시간 대신 로그 시간 또는 로그 k 시간에서 최소값을 찾는 데 사용할 수 있습니다. 최대값을 찾기 위해 처음에는 모든 0 인덱스의 최대값을 초기화합니다. 루프의 나머지 최대값에 대해서는 현재 최대값을 목록에서 최소 항목이 제거되는 다음 항목과 비교하기만 하면 됩니다. 나머지 접근 방식은 동일하게 유지됩니다. 

단계별 구현:

  • 최소 힙 선형 시간 대신 로그 시간 또는 로그 k 시간에서 최소값을 찾는 데 사용할 수 있습니다. 최대값을 찾기 위해 처음에는 모든 0 인덱스의 최대값을 초기화합니다. 루프의 나머지 최대값에 대해서는 현재 최대값을 목록에서 최소 항목이 제거되는 다음 항목과 비교하기만 하면 됩니다. 나머지 접근 방식은 동일하게 유지됩니다. 

    각 배열과 변수에서 하나씩 K개의 요소를 저장하는 최소 힙을 만듭니다. 최소 범위 최대값으로 초기화되고 변수도 유지됩니다. 최대 최대 정수를 저장합니다.

  • 최소 힙 선형 시간 대신 로그 시간 또는 로그 k 시간에서 최소값을 찾는 데 사용할 수 있습니다. 최대값을 찾기 위해 처음에는 모든 0 인덱스의 최대값을 초기화합니다. 루프의 나머지 최대값에 대해서는 현재 최대값을 목록에서 최소 항목이 제거되는 다음 항목과 비교하기만 하면 됩니다. 나머지 접근 방식은 동일하게 유지됩니다. 

    처음에는 각 목록의 첫 번째 요소를 넣고 최대값을 저장합니다. 최대 .

  • 최소 힙 선형 시간 대신 로그 시간 또는 로그 k 시간에서 최소값을 찾는 데 사용할 수 있습니다. 최대값을 찾기 위해 처음에는 모든 0 인덱스의 최대값을 초기화합니다. 루프의 나머지 최대값에 대해서는 현재 최대값을 목록에서 최소 항목이 제거되는 다음 항목과 비교하기만 하면 됩니다. 나머지 접근 방식은 동일하게 유지됩니다. 

    하나 이상의 목록이 소진될 때까지 다음 단계를 반복합니다. 

    • 최소값을 찾거나 분 최소 요소인 Min 힙의 최상위 또는 루트를 사용합니다.
    • 이제 업데이트하세요 최소 범위 전류(최대-최소)가 다음보다 작은 경우 최소 범위 .
    • 우선 순위 큐에서 최상위 또는 루트 요소를 제거하고 최소 요소가 포함된 목록에서 다음 요소를 삽입합니다.
    • 새 요소가 이전 최대값보다 큰 경우 삽입된 새 요소로 최대값을 업데이트합니다.
최소 힙 선형 시간 대신 로그 시간 또는 로그 k 시간에서 최소값을 찾는 데 사용할 수 있습니다. 최대값을 찾기 위해 처음에는 모든 0 인덱스의 최대값을 초기화합니다. 루프의 나머지 최대값에 대해서는 현재 최대값을 목록에서 최소 항목이 제거되는 다음 항목과 비교하기만 하면 됩니다. 나머지 접근 방식은 동일하게 유지됩니다. 

C++ 

#include    using namespace std; // Struct to represent elements in the heap struct Node {  int val row col;  bool operator>(const Node& other) const {  return val > other.val;  } }; // Function to find the smallest range vector<int> findSmallestRange(vector<vector<int>>& arr) {  int N = arr.size(); // Number of rows  int K = arr[0].size(); // Number of columns (same for each row)  priority_queue<Node vector<Node> greater<Node>> pq;  int maxVal = INT_MIN;  // Push the first element of each list into the min-heap  for (int i = 0; i < N; i++) {  pq.push({arr[i][0] i 0});  maxVal = max(maxVal arr[i][0]);  }  int minRange = INT_MAX minEl maxEl;  while (true) {  Node curr = pq.top(); pq.pop();  int minVal = curr.val;  // Update range if better  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  minEl = minVal;  maxEl = maxVal;  }  // If we've reached the end of a list break  if (curr.col + 1 == K) break;  // Push next element from the same list  int nextVal = arr[curr.row][curr.col + 1];  pq.push({nextVal curr.row curr.col + 1});  maxVal = max(maxVal nextVal);  }  return {minEl maxEl}; } // Driver code int main() {  vector<vector<int>> arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  vector<int> result = findSmallestRange(arr);  cout << result[0] << ' ' << result[1];  return 0; }
Java 
import java.util.*; // Class to represent elements in the heap class Node implements Comparable<Node> {  int val row col;  Node(int val int row int col) {  this.val = val;  this.row = row;  this.col = col;  }  // For min-heap based on value  public int compareTo(Node other) {  return this.val - other.val;  } } class GfG {  // Function to find the smallest range  static ArrayList<Integer> findSmallestRange(int[][] arr) {  int k = arr.length;  int n = arr[0].length;  PriorityQueue<Node> pq = new PriorityQueue<>();  int maxVal = Integer.MIN_VALUE;  // Push the first element of each list into the min-heap  for (int i = 0; i < k; i++) {  pq.add(new Node(arr[i][0] i 0));  maxVal = Math.max(maxVal arr[i][0]);  }  int minRange = Integer.MAX_VALUE minEl = -1 maxEl = -1;  while (true) {  Node curr = pq.poll();  int minVal = curr.val;  // Update range if better  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  minEl = minVal;  maxEl = maxVal;  }  // If we've reached the end of a list break  if (curr.col + 1 == n)  break;  // Push next element from the same list  int nextVal = arr[curr.row][curr.col + 1];  pq.add(new Node(nextVal curr.row curr.col + 1));  maxVal = Math.max(maxVal nextVal);  }  // Return result as ArrayList  ArrayList<Integer> result = new ArrayList<>();  result.add(minEl);  result.add(maxEl);  return result;  }  // Driver code  public static void main(String[] args) {  int[][] arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  ArrayList<Integer> res = findSmallestRange(arr);  System.out.println(res.get(0) + ' ' + res.get(1));  } }
Python 
import heapq # Function to find the smallest range def findSmallestRange(arr): k = len(arr) n = len(arr[0]) heap = [] maxVal = float('-inf') # Push the first element of each  # list into the min-heap for i in range(k): heapq.heappush(heap (arr[i][0] i 0)) maxVal = max(maxVal arr[i][0]) minRange = float('inf') minEl = maxEl = -1 while True: minVal row col = heapq.heappop(heap) # Update range if better if maxVal - minVal < minRange: minRange = maxVal - minVal minEl = minVal maxEl = maxVal # If we've reached the end of a list break if col + 1 == n: break # Push next element from the same list nextVal = arr[row][col + 1] heapq.heappush(heap (nextVal row col + 1)) maxVal = max(maxVal nextVal) return [minEl maxEl] # Driver code if __name__ == '__main__': arr = [ [4 7 9 12 15] [0 8 10 14 20] [6 12 16 30 50] ] res = findSmallestRange(arr) print(res[0] res[1])
C# 
using System; using System.Collections.Generic; // Class to represent elements in the heap class Node : IComparable<Node> {  public int val row col;  public Node(int val int row int col) {  this.val = val;  this.row = row;  this.col = col;  }  // For min-heap based on value  public int CompareTo(Node other) {  if (this.val != other.val)  return this.val.CompareTo(other.val);  // To avoid duplicate keys in SortedSet  if (this.row != other.row)  return this.row.CompareTo(other.row);  return this.col.CompareTo(other.col);  } } class GfG {  // Function to find the smallest range  static List<int> findSmallestRange(int[] arr) {  int k = arr.GetLength(0);  int n = arr.GetLength(1);  var pq = new SortedSet<Node>();  int maxVal = int.MinValue;  // Push the first element of each list into the min-heap  for (int i = 0; i < k; i++) {  var node = new Node(arr[i 0] i 0);  pq.Add(node);  maxVal = Math.Max(maxVal arr[i 0]);  }  int minRange = int.MaxValue minEl = -1 maxEl = -1;  while (true) {  var curr = GetMin(pq);  pq.Remove(curr);  int minVal = curr.val;  // Update range if better  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  minEl = minVal;  maxEl = maxVal;  }  // If we've reached the end of a list break  if (curr.col + 1 == n)  break;  // Push next element from the same list  int nextVal = arr[curr.row curr.col + 1];  var nextNode = new Node(nextVal curr.row curr.col + 1);  pq.Add(nextNode);  maxVal = Math.Max(maxVal nextVal);  }  return new List<int> { minEl maxEl }; // Return result as List    }  // Helper to get the minimum element (first element in SortedSet)  static Node GetMin(SortedSet<Node> pq) {  foreach (var node in pq)  return node;  return null;  }  // Driver code  static void Main() {  int[] arr = {  {4 7 9 12 15}  {0 8 10 14 20}  {6 12 16 30 50}  };  List<int> res = findSmallestRange(arr);  Console.WriteLine(res[0] + ' ' + res[1]);  } }
JavaScript 
class Node {  constructor(val row col) {  this.val = val;  this.row = row;  this.col = col;  } } // Function to find the smallest range function findSmallestRange(arr) {  const k = arr.length;  const n = arr[0].length;  const heap = new MinHeap();  let maxVal = -Infinity;  // Push the first element of each list into the min-heap  for (let i = 0; i < k; i++) {  heap.push(new Node(arr[i][0] i 0));  maxVal = Math.max(maxVal arr[i][0]);  }  let minRange = Infinity;  let minEl = -1 maxEl = -1;  while (true) {  const curr = heap.pop();  const minVal = curr.val;  // Update range if better  if (maxVal - minVal < minRange) {  minRange = maxVal - minVal;  minEl = minVal;  maxEl = maxVal;  }  // If we've reached the end of a list break  if (curr.col + 1 === n) break;  // Push next element from the same list  const nextVal = arr[curr.row][curr.col + 1];  heap.push(new Node(nextVal curr.row curr.col + 1));  maxVal = Math.max(maxVal nextVal);  }  return [minEl maxEl]; } // Min-heap comparator class MinHeap {  constructor() {  this.heap = [];  }  push(node) {  this.heap.push(node);  this._heapifyUp();  }  pop() {  if (this.size() === 1) return this.heap.pop();  const top = this.heap[0];  this.heap[0] = this.heap.pop();  this._heapifyDown();  return top;  }  top() {  return this.heap[0];  }  size() {  return this.heap.length;  }  _heapifyUp() {  let idx = this.size() - 1;  while (idx > 0) {  let parent = Math.floor((idx - 1) / 2);  if (this.heap[parent].val <= this.heap[idx].val) break;  [this.heap[parent] this.heap[idx]] = [this.heap[idx] this.heap[parent]];  idx = parent;  }  }  _heapifyDown() {  let idx = 0;  const n = this.size();  while (true) {  let left = 2 * idx + 1;  let right = 2 * idx + 2;  let smallest = idx;  if (left < n && this.heap[left].val < this.heap[smallest].val) {  smallest = left;  }  if (right < n && this.heap[right].val < this.heap[smallest].val) {  smallest = right;  }  if (smallest === idx) break;  [this.heap[smallest] this.heap[idx]] = [this.heap[idx] this.heap[smallest]];  idx = smallest;  }  } } // Driver code const arr = [  [4 7 9 12 15]  [0 8 10 14 20]  [6 12 16 30 50] ]; const res = findSmallestRange(arr); console.log(res[0] + ' ' + res[1]);

산출 
6 8