Maersk Quantum Optimization for Global Container Shipping Routes

The Problem

Maersk operates over 350 container vessels calling at more than 500 ports worldwide, moving roughly 12 million containers per year. Planning a single ocean lane involves assigning vessels to services, sequencing port calls, managing slow-steaming fuel trade-offs, and coordinating slot bookings with partner carriers, simultaneously. Across the full network, this is a multi-objective combinatorial optimization problem with hundreds of millions of interacting variables, far beyond the reach of exact classical solvers. Maersk’s operations research teams rely on heuristics and column generation methods that produce good solutions but cannot guarantee optimality or adapt quickly to disruptions.

The question Maersk brought to IBM Quantum and D-Wave was whether quantum and quantum-hybrid solvers could find better solutions than those heuristics, particularly on the fuel-versus-speed-versus-schedule trade-off that dominates Asia-Europe lane economics.

QUBO Formulation and Multi-Objective Encoding

The team decomposed the global problem by ocean region, treating each lane as a sub-problem that could be solved independently before a classical recombination step stitched the lane solutions into a coherent network plan.

For the Asia-Europe lane pilot with 20 vessels and 40 port calls, each binary variable encoded whether vessel V should call at port P at time T on service S. The objective function combined three terms: fuel cost (a nonlinear function of speed, approximated with piecewise linear segments), transit time, and port cost. Penalty terms enforced slot commitments and capacity constraints.

import dimod
from dwave.system import LeapHybridSampler

# Simplified QUBO for vessel-port-time assignment
# Variables: x[v][p][t] = 1 if vessel v calls port p at time t
bqm = dimod.BinaryQuadraticModel('BINARY')

alpha = 1.0   # fuel weight
beta  = 0.5   # transit time weight
gamma = 2.0   # constraint penalty weight

for v in vessels:
    for p in ports:
        for t in time_slots:
            var = f"x_{v}_{p}_{t}"
            fuel = fuel_cost(v, p, t)
            time_val = transit_time(v, p, t)
            bqm.add_variable(var, alpha * fuel + beta * time_val)

# One port call per vessel per service leg (one-hot constraint)
for v in vessels:
    for leg in service_legs[v]:
        leg_vars = [f"x_{v}_{p}_{t}" for p, t in leg_options[v][leg]]
        # Penalise selecting zero or more than one option
        for i, vi in enumerate(leg_vars):
            bqm.add_variable(vi, -gamma)
            for vj in leg_vars[i + 1:]:
                bqm.add_interaction(vi, vj, 2 * gamma)

sampler = LeapHybridSampler()
result = sampler.sample(bqm, time_limit=20)
best = result.first.sample

IBM QAOA on Sub-Network Problems

For a 12-port sub-network on the Europe-West Africa feeder service, the team used IBM’s Qiskit Optimization with a QAOA solver on the Eagle processor (127 qubits). The sub-network problem was small enough to fit on hardware after qubit mapping. QAOA with p=3 layers matched the quality of the classical Gurobi-based heuristic on this sub-problem, demonstrating that gate-based quantum optimization can reach competitive solution quality on tractable instances.

from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_algorithms import QAOA
from qiskit.primitives import Sampler

qp = QuadraticProgram()
# Add binary variables for each vessel-port-time triple in 12-port sub-network
for var in sub_network_vars:
    qp.binary_var(var)

qp.minimize(linear=linear_costs, quadratic=quad_penalties)

qaoa = QAOA(sampler=Sampler(), reps=3)
optimizer = MinimumEigenOptimizer(qaoa)
result = optimizer.solve(qp)
print(result.fval, result.x)

Hybrid Architecture and Results

The production architecture is explicitly hybrid. A classical orchestration layer handles data ingestion from Maersk’s vessel tracking systems, decomposes the global problem by lane, routes sub-problems to either D-Wave’s LeapHybridSampler or the IBM cloud API depending on problem structure, and then recombines lane solutions using classical integer programming. Neither quantum system sees the full global problem; they each handle structured sub-problems where quantum or quantum-hybrid search offers an edge over purely classical local search.

On the Asia-Europe lane test with 20 vessels, D-Wave’s hybrid solver identified vessel speed profiles and port call sequences that reduced projected fuel consumption by 8% relative to Maersk’s current heuristic baseline. At current bunker fuel prices, an 8% reduction across even a single major lane represents tens of millions of dollars in annual savings. Full fleet deployment, pending validation across additional lanes and disruption scenarios, is targeted for 2026.