How to Accurately Predict Flight Seat Occupancy and Waitlist Clearance

Flight Seat Occupancy and Waitlist Analysis

During a late‑night wait for a red‑eye flight, the author explains how to estimate how many seats will be filled and how many wait‑list passengers can be accommodated.

Seat occupancy rate is defined as actual seated passengers divided by sellable seats; wait‑list clearance rate is the number of wait‑list passengers who are upgraded divided by total wait‑list size. The method consists of two steps: (1) estimate the safe over‑booking amount k using historical no‑show probabilities for each cabin class, and (2) allocate seats in two stages using a priority queue that prefers confirmed bookings, higher cabin class, higher fare, and earlier order time.

The provided Java skeleton implements this logic. It calculates an average no‑show rate, determines a sell‑capacity, builds a comparator for priority ordering, assigns seats up to the sell‑capacity, estimates the expected number of shows, and computes final seated count, cleared wait‑list count, occupancy rate, and wait‑list clearance rate.

import java.util.*;
public class FlightAllocator {
    static class Pax {
        String id; boolean booked; int tier; double paid; long ts; double noShow;
        Pax(String id, boolean booked, int tier, double paid, long ts, double noShow){
            this.id=id; this.booked=booked; this.tier=tier; this.paid=paid; this.ts=ts; this.noShow=noShow;
        }
    }
    static class Result {
        int seatsAssigned; int waitlistCleared; double occRate; double wlClearRate;
        public String toString(){ return "occRate="+occRate+", cleared="+waitlistCleared; }
    }
    public static Result analyze(int totalSeats, List<Pax> booked, List<Pax> waitlist){
        // 1) estimate safe over‑sell amount
        double ns = booked.stream().mapToDouble(p->p.noShow).average().orElse(0.06);
        int k = (int)Math.round(booked.size() * ns); // safe over‑sell
        int sellCap = totalSeats + Math.max(k,0);
        // 2) priority queue: booked > tier > paid > earlier time
        Comparator<Pax> cmp = Comparator
            .comparing((Pax p)->!p.booked)
            .thenComparing((Pax p)->-p.tier)
            .thenComparing((Pax p)->-p.paid)
            .thenComparingLong(p->p.ts);
        PriorityQueue<Pax> pq = new PriorityQueue<>(cmp);
        booked.forEach(pq::offer); waitlist.forEach(pq::offer);
        // 3) assign up to sellCap
        List<Pax> assigned = new ArrayList<>();
        while(assigned.size() < sellCap && !pq.isEmpty()) assigned.add(pq.poll());
        // 4) estimate actual shows
        long bookedAssigned = assigned.stream().filter(p->p.booked).count();
        long wlAssigned = assigned.size() - bookedAssigned;
        int expectedShow = (int)Math.round(bookedAssigned*(1-ns) + wlAssigned*(1-ns));
        int finalSeated = Math.min(totalSeats, expectedShow);
        int waitlistCleared = (int)Math.max(0, Math.min(assigned.size(), sellCap) - booked.size());
        Result r = new Result();
        r.seatsAssigned = finalSeated;
        r.waitlistCleared = Math.min(waitlistCleared, waitlist.size());
        r.occRate = totalSeats==0?0:(finalSeated*1.0/totalSeats);
        r.wlClearRate = waitlist.isEmpty()?0:(r.waitlistCleared*1.0/waitlist.size());
        return r;
    }
    public static void main(String[] args){
        List<Pax> booked = Arrays.asList(
            new Pax("A", true, 3, 1200, 1, 0.05),
            new Pax("B", true, 1, 800, 2, 0.05)
        );
        List<Pax> wl = Arrays.asList(
            new Pax("W1", false, 2, 1000, 3, 0.05),
            new Pax("W2", false, 1, 700, 4, 0.05)
        );
        System.out.println(analyze(2, booked, wl));
    }
}

The solution addresses three practical concerns: quantifying how much over‑booking is safe, providing an explainable priority for wait‑list ordering, and producing metrics that can be displayed on dashboards. Accuracy can be improved by refining no‑show rates by cabin, departure time, and check‑in method, or by running Monte Carlo simulations for confidence intervals.