class Solution {

public:

    vector<int> smallestRange(vector<vector<int>>& nums) {

        int size = nums.size();

        vector<int> next(size, 0);

        int minx = 0, miny = INT_MAX;

        bool flag = true;

        for (int i = 0; i < size && flag; ++i) {

            for (int j = 0; j < nums[i].size() && flag; ++j) {

                int min_i = 0, max_i = 0;

                for (int k = 0; k < size; ++k) {

                    if (nums[min_i][next[min_i]] > nums[k][next[k]])

                        min_i = k;

                    if (nums[max_i][next[max_i]] < nums[k][next[k]])

                        max_i = k;

                }

                if (miny - minx > nums[max_i][next[max_i]] - nums[min_i][next[min_i]]) {

                    miny = nums[max_i][next[max_i]];

                    minx = nums[min_i][next[min_i]];

                }

                next[min_i]++;

                if (next[min_i] == nums[min_i].size())

                    flag = false;

            }

        }

        return {minx, miny};

    }

};

class Solution {

    public int[] smallestRange(List<List<Integer>> nums) {

        int minx = 0, miny = Integer.MAX_VALUE, max = Integer.MIN_VALUE;

        int[] next = new int[nums.length];

        boolean flag = true;

        PriorityQueue<Integer> min_queue = new PriorityQueue<Integer>((i, j)->nums[i][next[i]] - nums[j][next[j]]);

        for (int i = 0; i < nums.length; ++i) {

            min_queue.offer(i);

            max = Math.max(max, nums[i][0]);

        }

        for (int i = 0; i < nums.length && flag; ++i) {

            for (int j = 0; j < nums[i].length && flag; ++j) {

                int min_i = min_queue.poll();

                if (miny - minx > max - nums[min_i][next[min_i]]) {

                    minx = nums[min_i][next[min_i]];

                    miny = max;

                }

                next[min_i]++;

                if (next[min_i] == nums[min_i].length) {

                    flag = false;

                    break;

                }

                min_queue.offer(min_i);

                max = Math.max(max, nums[min_i][next[min_i]]);

            }

        }

        return new int[] {minx, miny};

    }

}

#include <vector>

#include <queue>

#include <limits>

using namespace std;

struct Item {

    int val;

    int r;

    int c;

    Item(int val, int r, int c): val(val), r(r), c(c) {

    }

};

struct Comp {

    bool operator() (const Item& it1, const Item& it2) {

        return it2.val < it1.val;

    }

};

class Solution {

public:

    vector<int> smallestRange(vector<vector<int>>& nums) {

        priority_queue<Item, vector<Item>, Comp> pq;

        int high = numeric_limits<int>::min();

        int n = nums.size();

        for (int i = 0; i < n; ++i) {

            pq.push(Item(nums[i][0], i, 0));

            high = max(high , nums[i][0]);

        }

        int low = pq.top().val;

        vector<int> res{low, high};

        while (pq.size() == (size_t)n) {

            auto it = pq.top();

            pq.pop();

            if ((size_t)it.c + 1 < nums[it.r].size()) {

                pq.push(Item(nums[it.r][it.c + 1], it.r, it.c + 1));

                high = max(high, nums[it.r][it.c + 1]);

                low = pq.top().val;

                if (high - low < res[1] - res[0]) {

                    res[0] = low;

                    res[1] = high;

                }

            }

        }

        return res;

    }

};

class Solution(object):

    def smallestRange(self, A):

        """

        :type nums: List[List[int]]

        :rtype: List[int]

        """

        pq = [(row[0], i, 0) for i, row in enumerate(A)]

        heapq.heapify(pq)

        ans = -1e9, 1e9

        right = max(row[0] for row in A)

        while pq:

            left, i, j = heapq.heappop(pq)

            if right - left < ans[1] - ans[0]:

                ans = left, right

            if j + 1 == len(A[i]):

                return ans

            v = A[i][j+1]

            right = max(right, v)

            heapq.heappush(pq, (v, i, j+1))

Priority queues are a type of container adapters, specifically designed such that the first element of the queue is the greatest of all elements in the queue and elements are in non decreasing order(hence we can see that each element of the queue has a priority{fixed order}).
 
The functions associated with priority queue are:
empty() – Returns whether the queue is empty
size() – Returns the size of the queue
top() – Returns a reference to the top most element of the queue
push(g) – Adds the element ‘g’ at the end of the queue
pop() – Deletes the first element of the queue

#include <iostream>

#include <queue> 

using namespace std; 

void showpq(priority_queue <int> gq)

{

    priority_queue <int> g = gq;

    while (!g.empty())

    {

        cout << '\t' << g.top();

        g.pop();

    }

    cout << '\n';

} 

int main ()

{

    priority_queue <int> gquiz;

    gquiz.push(10);

    gquiz.push(30);

    gquiz.push(20);

    gquiz.push(5);

    gquiz.push(1); 

    cout << "The priority queue gquiz is : ";

    showpq(gquiz); 

    cout << "\ngquiz.size() : " << gquiz.size();

    cout << "\ngquiz.top() : " << gquiz.top(); 

    cout << "\ngquiz.pop() : ";

    gquiz.pop();

    showpq(gquiz); 

    return 0;

}

come from : https://www.geeksforgeeks.org/priority-queue-in-cpp-stl/