```python
import collections
import heapq
import itertools

def func(nums, k):
    """
    Finds the top k integers that occur most frequently from given lists of
    sorted and distinct integers using a heap queue algorithm.
    """
    if not nums or k <= 0:
        return []

    # Step 1: Flatten the list of lists and count the frequency of each number.
    # itertools.chain is an efficient way to create a single iterator over all numbers.
    # collections.Counter builds a frequency map (dictionary) from the iterator.
    all_numbers = itertools.chain.from_iterable(nums)
    frequency_map = collections.Counter(all_numbers)

    # Step 2: Use a min-heap to find the k elements with the highest frequencies.
    # The heap will store tuples of (frequency, number) to allow comparison by frequency.
    min_heap = []
    for number, frequency in frequency_map.items():
        if len(min_heap) < k:
            # If the heap is not yet full, add the current element.
            heapq.heappush(min_heap, (frequency, number))
        elif frequency > min_heap[0][0]:
            # If the current element's frequency is greater than the smallest
            # frequency in the heap, replace the smallest element with the current one.
            # heapreplace is an efficient combination of pop and push.
            heapq.heapreplace(min_heap, (frequency, number))

    # Step 3: The heap now contains the top k elements. Extract just the numbers
    # from the (frequency, number) tuples.
    top_k_numbers = [number for frequency, number in min_heap]
    
    return top_k_numbers
```