// 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 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 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  ])   

   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 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  ]);   

   #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  ;   }   

   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  ));      }   }   

   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  ])   

   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  ]);      }   }   

   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  ]);   

   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  ));      }   }   

   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  ])   

   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  ]);      }   }   

   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  ]);