minheap.rs

intervals.radix_sort_unstable();

let mut slices = Vec::new();
let mut current_slice_start = 0;

for i in 1..intervals.len() {
    if intervals[i].start > intervals[i - 1].stop {
        slices.push(&intervals[current_slice_start..i]);
        current_slice_start = i;
    }
}

slices.push(&intervals[current_slice_start..]);

let _pairs = slices
    .into_par_iter()
    .fold(Vec::new, |mut acc, intervals| {
        let mut end_heap: BinaryHeap<Reverse<&Iv2>> =
            BinaryHeap::with_capacity(intervals.len());

        for interval in intervals {
            while let Some(&Reverse(ref end)) = end_heap.peek() {
                if end.stop <= interval.start {
                    end_heap.pop();
                } else {
                    break;
                }
            }

            acc.reserve(end_heap.len() * 2);

            end_heap.iter().for_each(|end| {
                acc.push((interval, end.0));
                acc.push((end.0, interval));
            });

            end_heap.push(Reverse(interval));
        }

        acc
    })
    .reduce(Vec::new, |mut acc1, mut acc2| {
        acc1.append(&mut acc2);
        acc1
    });