Mastering Binary Heaps for Scheduling, Merging, and Refueling: A CSCI 570 Homework 2 Guide

Introduction

Binary heaps are a fundamental data structure in computer science, often used to efficiently manage priority queues. In CSCI 570 at USC Viterbi, Homework 2 challenges students to apply binary heaps to three classic problems: scheduling classes in the SGM building, merging sorted research paper lists, and calculating minimum refueling stops for a spaceship. This tutorial will guide you through the core concepts and algorithmic strategies needed to tackle these problems, with timely examples drawn from current trends like the 2026 FIFA World Cup and the rise of AI-powered scheduling apps.

Why Binary Heaps Matter in 2026

As we approach the 2026 FIFA World Cup, scheduling matches across multiple stadiums requires efficient resource allocation—much like scheduling classes in a lecture hall. Similarly, merging sorted lists is akin to combining player statistics from different leagues into a unified ranking. And the refueling problem mirrors optimizing battery stops for electric vehicles on a cross-country road trip. Binary heaps, particularly min-heaps, provide O(log n) insertion and extraction, making them ideal for these tasks.

Problem 1: Scheduling Classes with Minimum Halls

Understanding the Problem

You have n classes, each with a start and end time. You need the minimum number of lecture halls so that no two classes overlap in the same hall. This is a classic interval scheduling problem.

Algorithm Using a Min-Heap

1. Sort the classes by start time.
2. Initialize a min-heap (priority queue) to store end times of classes currently occupying halls.
3. Iterate through sorted classes:
   • If the heap is not empty and the earliest ending class (heap top) ends before or when the current class starts, pop it (that hall becomes free).
   • Push the current class's end time onto the heap.
4. The size of the heap at any point is the number of halls needed; the maximum size is the answer.

Time Complexity

Sorting takes O(n log n). Each insertion and deletion on the heap takes O(log n), and we do O(n) operations, so total O(n log n).

Real-World Analogy: World Cup Match Scheduling

Imagine scheduling World Cup matches in stadiums. Each match has a start and end time. Using a min-heap of match end times, you can determine the minimum number of stadiums required. This is exactly how many sports scheduling systems work today.

Problem 2: Merging Sorted Lists Efficiently

Understanding the Problem

You have n sorted lists of research papers (by publication date), with a total of m papers. You need to merge them into one sorted list as fast as possible.

Algorithm Using a Min-Heap

1. Create a min-heap of size n. Each heap entry contains the first element of each list, along with the list index.
2. While the heap is not empty:
   • Extract the minimum element from the heap and add it to the result.
   • If the extracted element came from list i, and there is a next element in that list, insert that next element into the heap.

Time Complexity

Each insertion and extraction is O(log n). We perform m operations, so O(m log n). This is optimal for merging sorted lists.

Real-World Analogy: Music Streaming Playlists

Think of merging sorted playlists from different genres (pop, rock, classical) into one chronological playlist. A min-heap ensures you always pick the earliest song next, similar to how streaming apps like Spotify might combine curated lists.

Problem 3: Minimum Refueling Stops

Understanding the Problem

A spaceship starts with some fuel, consumes 1 unit per light-year, and can refuel completely at stations. You need the minimum number of stops to reach the target distance, or -1 if impossible.

Algorithm Using a Max-Heap

1. Sort stations by distance from origin.
2. Initialize a max-heap to store fuel capacities of stations you've passed but haven't refueled at.
3. Iterate through stations in order of distance, and also consider the final leg to target:
   • Maintain current fuel and current position.
   • When you reach a station (or the target), if you don't have enough fuel to get there, pop the largest fuel from the heap (refuel at that station) and increment stops.
   • After refueling, push the current station's fuel onto the heap (for future use).

Time Complexity

Sorting takes O(n log n). Each station is pushed and popped at most once, so O(n log n) overall.

Real-World Analogy: Electric Vehicle Road Trip

Imagine driving an electric car from Los Angeles to New York with charging stations along the way. You want to minimize charging stops. Using a max-heap of charging capacities, you always choose the station with the most charge when you run low—a strategy used by many EV route planners.

Common Pitfalls and Tips

• Always consider edge cases: empty lists, no stations, or insufficient fuel.
• Remember to handle the final leg to the target in the refueling problem.
• For scheduling, ensure you sort by start time, not end time.
• When merging, use a min-heap; for refueling, use a max-heap.

Conclusion

Binary heaps are powerful tools for optimization problems involving priorities. By mastering these three applications, you'll be well-prepared for CSCI 570 and real-world challenges. As you work through Homework 2, remember to analyze complexity and test with small examples. Good luck, and may your heaps always be balanced!