A Comparative Study of Quantum and Classical Pathfinding

Algorithms
Tharun Gurunath, Shireen Aliza Ali, RS Vignesh

Abstract
Quantum approaches, founded upon entanglement and superposition, hold theoretical promise
to accelerate certain combinatorial optimization problems, like variants of pathfinding, by poten-
tially exponential speedup. This paper presents a comparative analysis focused on the single-pair
shortest path problem on a specific 5-node weighted directed graph. We benchmark established
classical algorithms—Dijkstra, A* (using Euclidean distance heuristic), Bellman-Ford, Breadth-
First Search (BFS), and Depth-First Search (DFS)—against the Quantum Approximate Optimiza-
tion Algorithm (QAOA), a leading variational quantum algorithm suitable for near-term hardware.
We provide a detailed mathematical framework for translating the shortest path problem into the
Quadratic Unconstrained Binary Optimization (QUBO) format required by QAOA. This involves
defining binary variables for each edge, formulating a linear objective function representing the
total path cost, and incorporating flow conservation constraints to ensure path validity. This con-
strained optimization problem is then converted into a QUBO using standard Qiskit optimization
tools. We implement the QAOA algorithm using Qiskit, configuring it with a p=1 layer ansatz
and the COBYLA classical optimizer. The performance of QAOA is evaluated through execution
on both the Qiskit Aer statevector simulator for local testing and, for a practical perspective on
near-term hardware, on IBM Quantum’s ”ibm kyoto” backend. Performance metrics, in particu-
lar the precision of the estimated path cost and the total running time, are meticulously tracked
and compared for all classical and quantum variants. This numerical comparison aims to provide
insight into the extreme computational overhead, running time, and solution quality differences
between the standard classical paradigm and the emerging quantum paradigm for this common
graph optimization problem, providing perspective on the current-day practical status and future
potential of QAOA for pathfinding problems.

1 Introduction
Pathfinding, or the algorithm for determining the best path between fixed points in a graph-based
model, is a natural problem for computer science and operations research. Its use extends to various
industries, including network routing, logistics, robotics navigation, and artificial intelligence [2][5].
Among the various pathfinding challenges, determining the shortest path between two specified
nodes in a weighted graph is a canonical optimization task, critical for minimizing cost, time, or
distance in countless real-world scenarios. For decades, classical computing has provided a robust
suite of algorithms capable of efficiently solving this problem. Dijkstra’s algorithm, A* search, and
Bellman-Ford have become standard tools, offering polynomial-time solutions that are well-understood
and widely implemented.
But with the advent of quantum computing comes a potential paradigm shift, one that provides new
computational capabilities which can potentially revolutionize our approach to solving optimization
problems, like pathfinding. Having the capacity to explore huge computational spaces simultane-
ously using superposition and entanglement potentially offers the theoretical prospect of exponential
speedup over classical pathfinding analogues for certain classes of problems. This has encouraged
considerable work in building quantum algorithms for graph problems. Initial quantum methods,
including quantum-inspired optimization algorithms such as Quantum Particle Swarm Optimization
(QPSO), have been investigated for applications such as robotic pathfinding, with metrics such as
path cost and execution time [2]. At a lower level, scientists are working on algorithms that explicitly
utilize quantum phenomena. Wesolowski and Piddock’s work investigates quantum algorithms for the
single-pair shortest path problem that are optimized through techniques such as quantum flow √ state
sampling and divide-and-conquer. The work untangles such promising complexities as O(l m) and

1
 √
O( lm), based on particular graph properties and available resources. The work further suggests that
speedup may be achievable for instances of graphs with a comparatively small shortest-path length
(l) [1]. Notably, such complexities come close to the minimum thresholds required just to recognize a
path, suggesting considerable room for efficiency enhancement [1].
One direction leverages the fundamental ideas of amplitude amplification, similar to Grover’s search
algorithm. Koch et al. suggest a ”Gaussian Amplitude Amplification” approach in which a custom
”cost oracle” encodes the weights of all potential paths into the phases of respective quantum states [3].
In the case where cumulative path weight distribution is very similar to a Gaussian distribution—a
property observed graph structures like sequential bipartite graphs—the approach can strongly im-
prove the possibility of identifying states corresponding to paths of minimum or maximum weight
[3]. The approach goes beyond simple unstructured search methods and solves structured optimiza-
tion problems by capitalizing on the inherent distribution of candidate solutions. In spite of such
encouraging theoretical progress and algorithmic breakthroughs, practical implementation of quantum
computing is plagued by serious challenges. Presently, the quantum hardware is in the regime of Noisy
Intermediate-Scale Quantum (NISQ) with low qubit numbers, small coherence times, and high gate
error rates [4]. The demonstration of genuine quantum supremacy for demanding problems hinges on
the realization of large-scale fault-tolerant quantum computers (FTQC).
This requirement calls for high-level quantum error correction (QEC), which generally involves
encoding a single robust logical qubit through the employment of hundreds or even thousands of delicate
physical qubits in standard superconducting systems, such as those being developed by IBM and Google
[4]. This high demand for resources highlights the scaling difficulties. Microsoft’s pursuit of topological
qubits based on Majorana fermions represents an alternative strategy, aiming to build qubits with
inherent fault tolerance, potentially reducing the QEC overhead dramatically and accelerating the path
towards the million-qubit processors deemed necessary for tackling classically intractable problems like
breaking RSA encryption or complex molecular simulations [4]. Furthermore, translating optimization
problems like shortest path finding into a format suitable for quantum algorithms, such as the Quantum
Approximate Optimization Algorithm (QAOA) implemented in this study’s code, is often non-trivial.
Many quantum optimization approaches require the problem to be cast as a Quadratic Unconstrained
Binary Optimization (QUBO), a formulation process that demands significant expertise and can be
error prone [5]. Frameworks are being developed now to aid this process of translation, to connect
domain experts and the intricacy of quantum programming [5].
With this backdrop—classical algorithms traditionally mature, quantum algorithms rapidly devel-
oping with theoretical potential, NISQ hardware limited in practical application, eventual long-term
potential for fault-tolerance, and problem formulation concerns—a direct comparison at the point of
interest is between classical and quantum methodologies. This work offers a comparative study of algo-
rithms to find the shortest path on a weighted directed graph. We contrast traditional well-established
algorithms (Dijkstra, A*, Bellman-Ford, Breadth-First Search, Depth-First Search) with a state-of-
the-art variational quantum algorithm, QAOA, coded in Qiskit and executed in simulators and IBM
quantum devices. By analyzing the performance metrics, e.g., correctness of the path cost calculation
and execution speed, this project intends to shed some light on the current practical reality and pos-
sible trade-offs among these essentially different computational paradigms for a sample optimization
problem with a graph-based representation.
The fundamental contributions of this study are:
• Implementation and comparative benchmarking of five classical pathfinding algorithms (Dijkstra,
A*, Bellman-Ford, BFS, DFS) and the QAOA quantum algorithm for the shortest path problem
on a specified 3D weighted directed graph.

• A full explanation of the QAOA method employed, e.g., casting as a Quadratic Program with
flow constraints and subsequently mapping onto a QUBO.
• Quantitative comparison of algorithm performance in terms of execution time and resulting path
cost, obtained from simulations.

• An experimental study of implementing the QAOA formulation on IBM Quantum hardware,

reporting on the setup and outcomes.
• Visualization of the graph structure and the paths discovered by each algorithm for comparison.

2
 This work aims to provide practical insights into the status of QAOA for pathfinding versus classical
benchmarks, illustrating both the process and performance challenges on simulators and near-term
hardware.

2 Literature Review
Quantum-technically, research has explored the possibility of applying quantum algorithms in solving
the knotty pathfinding problem. Studies showcase how quantum computers are significantly faster com-
pared to classical approaches to computing shortest paths [1][3][5]. The study establishes the advantage
of employing quantum entanglement and superposition in examining multiple routes simultaneously,
leading to a speedup that is exponential on hard problems of network travel [9]. Hybrid frameworks
have been recognized as a promising field of progress. This strategy combines quantum computing
with traditional multi-agent systems to achieve optimal pathfinding efficiency [14][16]. Through the
offloading of computationally intensive subproblems onto quantum processors with retaining classical
heuristics for real-world constraints, this hybrid system exhibits unparalleled performance in dynamic
and large-scale scenarios [15][17]. The results demonstrate that hybrid models can close the gap be-
tween classical constraints and full quantum implementations. The second primary contribution is a
systematic approach to pathfinding problem formulation and solution in a broad array of applications,
including UAV navigation [5]. The architectural basis relies on the modular problem formulation so
that researchers can systematically integrate energy-efficient constraints, environmental issues, and
avoiding obstacles in pathfinding solution schemes [12]. In total, recent research demonstrates the po-
tential of quantum and hybrid approaches to revolutionize pathfinding in autonomous UAVs. Though
classical approaches also advance, quantum algorithms and hybrid approaches offer revolutionary gains
in computational efficiency and scalability [1][6][7]. Future research must try to close gaps between the-
oretical advancements and real implementations in order for quantum-inspired pathfinding solutions
to be easily applied to real UAV applications [8][11].

3 Background
3.0.1 Traditional Pathfinding Algorithms
Classical computing provides numerous well-known pathfinding algorithms in graph domains with
performance properties and guarantees that vary. To find the shortest path in weighted graphs with
non-negative edge weights, like analysis in the graph defined by ‘CUSTOM WEIGHTS‘ in this study,
Dijkstra’s algorithm is a typical solution [6]. It guarantees finding the minimum total weight path
by iteratively visiting nodes according to their accumulated distance from the source, typically imple-
mented with a priority queue. The update rule in the core ensures optimality:

d[v] = min(d[v], d[u] + w(u, v), (1)

where d[v] is the shortest distance found thus far from the source to vertex v, u is the vertex be-
ing processed, and w(u, v) is the weight of the edge from u to v. Our implementation employs the
‘networkx.dijkstra path‘ function.
The A* search algorithm frequently enhances Dijkstra’s algorithm by adding a heuristic function
h(v), making it possible to have directed search toward the goal node. It prioritizes nodes according
to this function:
f (v) = g(v) + h(v) (2)
where g(v) is the estimated cost (total weight) from the source node to node v, and h(v) is an admissible
heuristic estimate of the cost from node v to the goal node. For A* to guarantee optimality, the
heuristic function must be admissible (never overestimate the optimal cost). In our implementation
(networkx.astar path), we use the Euclidean distance in 3D space between node v and the target node
as the heuristic, computed from the coordinates in ‘node positions‘. In addition, we compare against
the Bellman-Ford algorithm (networkx.bellman ford path), which supports graphs with negative edge
weights (but not negative cycles) and is typically less efficient than Dijkstra’s for graphs with non-
negative weights. In addition, we include Breadth-First Search (BFS) and Depth-First Search (DFS),
implemented via functions bfs path and dfs path, respectively. While these algorithms are efficient for

3
graph traversal, BFS excels at finding the shortest path in terms of the number of edges in unweighted
graphs, while DFS provides a path with no guarantees regarding its cost or length; moreover, neither
approach is set up to prioritize minimum weight in a weighted graph.

3.1 QUBO Formulation for Shortest Path

To apply quantum optimization algorithms like QAOA, the shortest path problem must be formulated
as a Quadratic Unconstrained Binary Optimization (QUBO) problem [8]. The goal is to find a vector
of binary variables x that minimizes an objective function quadratic in the variables:
X X
Minimize C(x) = ai xi + bij xi xj , xi ∈ {0, 1}. (3)
i i<j

In our formulation for the shortest path problem from a source node s to a target node t, we associate
a binary variable xij with each directed edge (i, j) ∈ E in the graph G = (V, E). xij = 1 signifies that
edge (i, j) is part of the chosen path, and xij = 0 otherwise. The primary goal is to reduce the total
weight of the edges that are chosen. This constitutes the linear component of the QUBO objective
function: X
Objective : wij xij , (4)
(i,j)∈E

where wij is the weight on edge (i, j) taken from ‘CUSTOM WEIGHTS‘. This is done through
‘qp.minimize(linear=. . . )‘ in the Qiskit ‘QuadraticProgram‘.
To make the chosen edges represent a valid path from s to t, we need to add some constraints. We
introduce flow conservation constraints at every node v ∈ V . These constraints stipulate that at any
node:
• The net flow (number of outgoing edges selected minus number of incoming edges selected) is
+1 for the source node s.
• The net flow for the destination node t is -1.
• The net flow is 0 for all intermediate nodes v ∈
/ {s, t}.
Mathematically, for all nodes v ∈ V :

X X 1
 if v = s
xvj − xiv = −1 if v = t (5)

j:(v,j)∈E i:(i,v)∈E 
0 otherwise

These are expressed as linear equality constraints with ‘qp.linearconstraint‘ in the Qiskit ‘Quadrat-
icProgram‘.
Lastly, the converter designated as ‘QuadraticProgramToQubo‘ is utilized. This essential step con-
verts the ‘QuadraticProgram‘, both encompassing the linear objective and linear equality constraints,
into a corresponding QUBO representation. This is done by aggregating the constraints inside the
objective function as quadratic penalty terms. These are naturally formulated to render any failure in
satisfying the flow conservation constraints expensive in terms of the objective function value, thereby
directing the minimization task towards feasible path solutions. The resulting QUBO encodes the cost
minimization as well as path validity constraint.

3.2 Quantum Approximate Optimization Algorithm (QAOA)

The Quantum Approximate Optimization Algorithm (QAOA) is a variational quantum-classical hybrid
algorithm that is run to find an approximate solution for combinatorial optimization problems, more
precisely those in QUBO form [7]. It does this by first initializing a quantum state |ψ(γ, β)⟩ by
alternately applying two Hamiltonians: the problem Hamiltonian HP and the mixer Hamiltonian HM .
For p layers (iterations):
p
!
Y
−iβk HM −iγk HP
|ψ(γ, β)⟩ = e e |+⟩⊗n (6)
k=1

4
where || : +⟩⊗n is the equal superposition state over n qubits (one for each binary variable xij ), and
(γ, β) = (γ1 , ., γp , β1 , ., βp ) are the variational parameters.
The Problem Hamiltonian (HP ) encodes the QUBO objective function C(x). It is diagonal in
the computational basis, with eigenvalues corresponding to the cost function values for each possible
binary assignment x. Typically, it is constructed by mapping binary variables xk to Pauli-Z operators
acting on the k-th qubit, often via xk 7→ (1 − σkz )/2. The resulting HP is a sum of Pauli-Z terms
corresponding to the linear and quadratic terms in the QUBO.
The Mixer Hamiltonian (HM ) calls upon quantum coherence and allows for searching of the
solution space. The default choice, used here, is the sum over all qubits of Pauli-X operators:
n
X
HM = σkx (7)
k=1

where the sum is over all n qubits that index the edge variables. This mixer allows for transitions
among path configurations (computational basis states). In our Qiskit example, we apply the ‘QAOA‘
algorithm with ‘reps=1‘ (i.e., p = 1 layer). A classical optimizer (‘COBYLA‘ with ‘maxiter=50‘) is
run on a classical computer to update the parameters (γ1 , β1 ) iteratively. Its goal is to minimize the
expectation value ⟨ψ(γ1 , β1 )|HP |ψ(γ1 , β1 )⟩, which approximates the minimum value of the original
QUBO cost function. The ‘MinimumEigenOptimizer‘ orchestrates this hybrid process. Quantum
state preparation and measurement are performed using ‘QuantumInstance‘, configured for either
the ‘AerSimulator‘ or, when specified (‘use ibm=True‘), the ‘ibm kyoto‘ backend via IBM Quantum
services, employing 1024 measurement shots and optimization level 3 for circuit optimization. The
ultimate result of the measurement gives a probabilistic solution, and the lowest cost valid path is
found by looking at the binary variables for the measurement outcomes of high probability.

4 Comparative Framework and Implementation

This study takes a comparative method of quantifying the performance of classical pathfinding al-
gorithms against the Quantum Approximate Optimization Algorithm (QAOA) in relation to solving
the shortest path problem on a specified weighted directed graph. The method is realized using the
Python programming language, utilizing properly documented libraries for both graph manipulation
and quantum circuit simulation and execution.

4.1 Implementation Aspects

The core implementation relies on the NetworkX library for graph creation, manipulation, and analysis,
and IBM’s Qiskit suite (qiskit, qiskit optimization, and qiskit.providers.aer) for quantum circuit cre-
ation, simulation, and execution. The workflow has several distinct phases, described algorithmically
and outlined below:
1: Graph Definition: The topology of the graph is specified as G = (V, E) through NetworkX.DiGraph().
The nodes V = {0, 1, 2, 3, 4} are given three-dimensional space coordinates which are kept in the
node positions dictionary. Directed edges E, each with corresponding weights wij , are inserted
according to the CUSTOM WEIGHTS dictionary (for example, the edge (0,1) has a weight of
2.4).
2: Classical Benchmarking: Run classical algorithms (Dijkstra, A*, Bellman-Ford, BFS, DFS)
on native NetworkX implementations (nx.dijkstra path, nx.astar path with Euclidean heuristic
from node positions, nx.bellman ford path) and manual implementations (bfs path, dfs path) for
completeness. Execution time and path cost for all.
3: QUBO Formulation: We formulate the shortest path problem for QAOA as a Quadratic Pro-
gram (QP) with qiskit optimization.QuadraticProgram. We introduce a binary variable xij for each
edge (i, j) ∈ E with qp.binaryPvar(’x ij’). Then, we define the linear objective function to minimize
the total path weight: min (i,j)∈E wij xij , carried out by qp.minimize(linear=objective linear).
Subsequently, we added flow conservation constraints on all nodes k ∈ V as linear P equalityPcon-
straints by calling qp.linear constraint(coeffs, ’==’, rhs, ’flow node k’, such that j xkj − i xik
is 1 for the source, -1 for the target, and 0 for all other nodes.

5
4: QUBO Conversion: Convert the constrained Quadratic Program to an unconstrained QUBO
ready for Quantum Approximate Optimization Algorithm (QAOA). Such a conversion is assisted
by the qiskit optimization.converters.QuadraticProgramToQubo converter. In this conversion, the
linear constraints are converted to quadratic penalty terms added to the QUBO objective function.
The converted QUBO specifies the problem Hamiltonian HP .
5: QAOA Configuration:
Initialize the qiskit.algorithms.QAOA object. Choose a standard optimization routine for the
variational parameters (γ, β). The run utilizes qiskit.algorithms.optimizers.COBYLA with a max-
imum of 50 iterations (maxiter=50). Fix the number of QAOA iterations (layers) p = 1 (reps=1).
This selection is based on constraints typically enforced by existing NISQ hardware depth limits.
Specify initial variational parameters, e.g., γ1 = 0.1, β1 = 0.1 (initial point=[0.1, 0.1]). Config-
ure the quantum backend using qiskit.utils.QuantumInstance. Options include a local simulator
(Aer.get backend(’aer simulator’)) or real IBM Quantum hardware (e.g., ibm kyoto accessed via
qiskit.providers.ibmq.IBMQ). The implementation attempts to use ibm kyoto if use ibm=True and
an IBM Quantum token is provided via environment variables, falling back to the simulator oth-
erwise. Specify the amount of measurement shots (e.g., 1024) and circuit optimization level (e.g.,
3).
6: Quantum Execution and Optimization: Utilize the qiskit optimization.algorithms. Mini-
mumEigenOptimizer wrapper, taking the configured QAOA instance. Calling
optimizer.solve(qp qubo) executes the hybrid QAOA loop: execution of the parameterized circuit
on the backend, expectation value calculation of HP , and classical optimization of (γ, β) via
COBYLA.
7: Result Extraction: Decode the binary solution vector result.x from the optimizing process.
Edges (i, j) corresponding to variables xij for which result.x[index] > 0.5 are accepted as compo-
nents of the suggested path.
8: Path Reconstruction: Reconstruct the sequence of nodes from source to target via the recon-
struct path function using the identified path edges. Calculate the total path cost using the original
edge weights. Note the total execution time for the QAOA process.
9: Comparison & Visualization: Accumulate the results (path, cost, time) of all algorithms.
Present results in a table and plot graph and resulting paths in 3D using matplotlib.pyplot and
mpl toolkits.mplot3d, plotting nodes according to node positions and highlighting the discovered
path of each algorithm.

Figure 1: System architecture diagram showcasing the key components and their interactions.

6
4.1.1 Code Analysis: run qaoa Function
The main role of the quantum element is represented as ’run qaoa’. Its main responsibilities, as
performed, are:
• Variable Definition: Dynamically creates binary variables xij in the ‘QuadraticProgram‘ ob-
ject, one for every potential edge (i, j) of the input graph G.
• Objective Function: Defines the optimization goal as minimizing the total weights of chosen
edges. This is formulated as a linear combination of the binary variables, where the coefficient
of xij is exactly the weight wij from the graph (utilizing the variable ‘objective linear‘).
• Constraint Enforcement: The procedure involves iterating over every node present in the
graph to create and add the flow conservation constraints (Equation 5). For every individual
node, it finds incoming and outgoing edges, sets the right coefficients (+1 for outgoing edges and
-1 for incoming edges), sets the appropriate right-hand side (rhs) depending on whether the node
is classified as source (1), target (-1), or intermediate (0), and adds this as an equality constraint
via ‘qp.linear constraint‘.
• QUBO Conversion and Execution: Utilizes the ‘QuadraticProgramToQubo‘ converter and
the ‘MinimumEigenOptimizer‘ framework, encapsulating the step-by-step process of converting
the QUBO toPthe problem Hamiltonian HP , building the QAOA ansatz circuit with the given
mixer HM = σkx , executing the variational optimization loop with the selected classical opti-
mizer (COBYLA) and quantum backend, and producing the optimization outcome.
• Solution Decoding: Scans the binary result vector ‘result.x‘ to determine the active edges, i.e.,
the edges whose variable values are near 1, which together form the approximate shortest path
discovered by QAOA.

4.2 Case Study: Specific 5-Node Graph Analysis

The model was run on a particular 5-node directed graph defined by ‘node positions‘ and ‘CUS-
TOM WEIGHTS‘. We focused on obtaining the shortest distance from source node A = 0 to target
node E = 3. The shortest path actually computed is 0 → 2 → 3 for a total cost of w(0, 2) + w(2, 3) =
2.8 + 1.7 = 4.5.
To run QAOA, the problem was encoded into a QUBO. The problem Hamiltonian HP , which
is implicitly P
derived by the ‘QuadraticProgramToQubo‘ converter, encodes both the objective (mini-
mization of wij xij ) and the flow constraints (Equation 5) in terms of Pauli-Z operators acting on
the qubits that represent the xij variables. For instance, the objective function includes terms such
as −2.4Z 01, −2.8Z 02, etc. (after any conversion of x ij to spin variables in the form of (1 − Z)/2).
At the same time, the flow constraint for the source node k = 0 (x01 + x02 + x04 = 1) would be
re-written in the form of penalty terms involving interactions between the concerned qubits (e.g.,
P (Z01 + Z02 + Z04 − c)2 for some constant P and a shift c). The QAOA circuit was initialized with
p = 1 layer (‘reps=1‘).
The COBYLA optimization routine was employed to find the optimum values of the angles γ 1
and β 1 with a maximum of 50 iterations (‘maxiter=50‘), from initial guesses γ 1 = 0.1 and β 1 = 0.1.
The quantum-classical combined optimization was performed for the minimization of the expectation
value ⟨HP ⟩. The final preparation and measurement give the probability distribution over the possible
paths, and then the lowest-cost path found by QAOA is taken. Then, the performance is compared
with the classical one using the recovered path cost and total running time.

4.3 Code
To view Python implementation, visit https://github.com/helloimajoke/quantum pathfinding

5 Results and Discussion

5.1 Analysis of Results
Based on the performance comparison presented in Table 1, several key observations can be made:

7
 Table 1: Performance Comparison: Shortest Path on 5-Node Graph (Source 0 to Target 3)
Algorithm Time (s) Total Cost Path
Dijkstra 0.0000 4.5000 [0, 2, 3]
A* 0.0000 4.5000 [0, 2, 3]
Bellman-Ford 0.0000 4.5000 [0, 2, 3]
BFS 0.0000 5.4000 [0, 1, 3]
DFS 0.0000 5.4000 [0, 1, 3]
QAOA (Simulator) 21.6626 4.5000 [0, 2, 3]
QAOA (IBM Kyoto) 3.5379 4.5000 [0, 2, 3]

Figure 2: Path with vertices for different algorithms.

From the performance comparison provided in Table 1, we can draw the following significant con-
clusions: The classic shortest path algorithms Dijkstra, A*, and Bellman-Ford were significantly faster
in their execution speed when applied to a 5-node simple graph. These highly optimized algorithms
provided solutions in sub-millisecond times, several orders of magnitude faster than the QAOA imple-
mentations. In contrast, both the simulation with QAOA and its execution on the IBM Kyoto quantum
backend were considerably slower—approximately 21.6 seconds for the simulator and approximately
3.54 seconds on IBM Kyoto—to converge to the optimal solution as indicated in Figure 2.
The disparity indicates that for small problems, classical methods are much quicker in execution
time. Despite the decreased performance, both QAOA implementations managed to converge success-
fully to the optimum route, at a minimum cost of 4.5000. This illustrates that the quantum approach,
even with its intrinsic overhead, can produce outcomes matching the optimal results derived from
classical methods. The procedure entails a number of computationally demanding stages, such as

8
state preparation, circuit running, the classical optimization loop, and measurement sampling. These
additional layers also contribute to the computational overhead overall, lowering QAOA’s competitive-
ness in cases where classical algorithms can already provide exact and effectively instantaneous results
in scenarios. Despite traversal algorithms like Breadth-First Search (BFS) and Depth-First Search
(DFS) being equally renowned for their speed, the application here revealed a caveat to their use. The
algorithms, which were designed to traverse graphs in an optimal way, did not consider the weighted
costs associated with the paths. As a result of this, even though they can provide quick results, the
paths found by both BFS and DFS were not optimal, with a total cost of 5.4000, thus highlighting
their failure to find the optimal weighted path.
In addition, a striking observation was the difference in the time of execution between simulation
and hardware-based quantum computing. The IBM Kyoto backend, which operates on real quantum
hardware, executed the QAOA more quickly than the local Aer simulator. At first glance, this appears
counterintuitive; nonetheless, this difference in performance is presumably caused by the differences in
the simulation approaches used, including the type of simulation (i.e., statevector simulation or actual
quantum hardware run), and cloud-based quantum job scheduling and communication computational
overhead. From a scalability perspective, these experiments reinforce the notion that for as simple a
problem as a 5-node graph, classical algorithms not only run in polynomial time but also yield solu-
tions with unmatched efficiency. On the other hand, modern quantum algorithms like QAOA involve
significant overhead, and their practical advantages do not manifest at this small scale. The antici-
pated benefits of quantum computation—possible speedup for problems with exponentially increasing
complexity—are likely to become applicable only to much larger or more complex graph instances
and with more advanced quantum hardware. Therefore, while QAOA is a useful proof-of-principle for
quantum algorithm design, its current form does not offer a performance benefit over classical methods
for simple pathfinding problems.

6 Conclusion
This project involved a comparative analysis of classical pathfinding algorithms and the Quantum
Approximate Optimization Algorithm (QAOA) for solving the shortest path problem in a standard
5-node weighted directed graph. By utilizing standard classical methods (Dijkstra, A*, Bellman-
Ford, BFS, DFS) and QAOA via Qiskit and executed on simulators and IBM Quantum hardware,
we compared performance based on correctness of solutions (minimum path cost) and execution time
taken. The findings unequivocally indicate that for this example of a small-scale issue, conventional
algorithms specifically tailored for shortest path optimization (Dijkstra, A*, Bellman-Ford) give con-
siderably better speed performance, giving the correct solution almost instantly. While QAOA with a
p = 1 ansatz and COBYLA optimizer did ultimately yield the identical optimal route and minimum
cost, it incurred high computational overhead, resulting in orders-of-magnitude longer execution times
compared to classical counterparts (Table 1).
This is a reflection of the efficiency of mature classical solutions for polynomial-time solvable prob-
lems and the high overhead that comes with variational quantum algorithms, including QUBO for-
mulation, circuit running, classical optimization, and measurement sampling. The comparison also
confirmed that straightforward traversal algorithms like BFS and DFS, while efficient, do not mini-
mize path weight. The faster execution time observed on the IBM Kyoto hardware compared to the
local simulator suggests advanced interaction between simulation techniques, hardware execution char-
acteristics, and communication delays, as opposed to some quantum speedup inherent to this problem
size. This study emphasizes that, in demonstrating the functional precision of QAOA to this opti-
mization problem, in instances of this scale where many efficient classical solutions exist, the current
quantum algorithms of the NISQ era do not provide a notable computational advantage as of now.
The potential benefits of quantum techniques like QAOA, Gaussian Amplitude Amplification [3], or
quantum walk-based algorithms [1] should come in larger and more complex problem instances where
classical algorithms have issues with scaling. Having these benefits will necessitate going beyond the
NISQ era to fault-tolerant quantum computing [4], with advancements in qubit quality, error correction,
algorithm design, and perhaps leveraging frameworks that simplify problem formulation to quantum
execution [5]. Future work must involve extending this analysis to larger graphs, exploring deeper
QAOA circuits (p > 1), testing other classical optimizers and parameter initialization schemes, and
perhaps comparison to other quantum algorithmic paradigms in order to more clearly delineate the

9
regimes where quantum pathfinding may yield substantial benefits.

References
[1] A. Wesolowski, S. Piddock, Advances in quantum algorithms for the shortest path problem, arXiv
preprint arXiv:2408.10427v2, 2024.

[2] R. Maity, R. Mishra, P. K. Pattnaik, Analysis of Path finding techniques for flying robots through in-
telligent decision making algorithms in Quantum inspired computing environment, Research Square
preprint, DOI: 10.21203/rs.3.rs-2709395/v1, 2023. [Version of Record published in Wireless Per-
sonal Communications, DOI: 10.1007/s11277-024-11125-z, 2024].

[3] D. Koch, M. Cutugno, S. Karlson, S. Patel, L. Wessing, P. M. Alsing, Gaussian Amplitude Ampli-
fication for Quantum Pathfinding, Entropy, vol. 24, no. 7, p. 963, 2022. DOI: 10.3390/e24070963.
[4] D. C. Youvan, Microsoft’s Majorana 1: A Paradigm Shift Toward Scalable and Fault-Tolerant
Quantum Computing, Preprint, DOI: 10.13140/RG.2.2.11176.89607, February 2025 (Date as spec-
ified in document).

[5] D. Rovara, N. Quetschlich, R. Wille, A Framework to Formulate Pathfinding Problems for Quantum
Computing, arXiv preprint arXiv:2404.10820v1, 2024.
[6] E. Dijkstra, A Note on Two Problems in Connexion with Graphs, Numerische Mathematik, 1959.
[7] E. Farhi et al., A Quantum Approximate Optimization Algorithm, arXiv:1411.4028, 2014.

[8] F. Glover et al., A Tutorial on Formulating QUBO Models, arXiv:1811.11538, 2018.

[9] J. Li, Y. Tong, Exponential Quantum Advantage for Pathfinding in Regular Sunflower Graphs,
arXiv preprint arXiv:2407.14398, 2024.
[10] H. Ma, J. Li, S. Kumar, Coordinated Multi-Agent Pathfinding for Drones and Trucks over Road
Networks, arXiv preprint arXiv:2110.08802, 2021.
[11] N. Mohanty, A. Sharma, P. Tiwari, Solving the Vehicle Routing Problem via Quantum Support
Vector Machines, arXiv preprint arXiv:2308.04849, 2023.
[12] T. Bennett, A. Nash, R. Patel, Quantum Walk-Based Vehicle Routing Optimisation, Frontiers in
Physics, vol. 9, 2021. DOI: 10.3389/fphy.2021.730856.

[13] I. D. Leonidas, G. Kostopoulos, D. Karalekas, Qubit Efficient Quantum Algorithms for the Vehicle
Routing Problem on NISQ Processors, arXiv preprint arXiv:2306.08507, 2023.
[14] T. Gerlach, M. Streif, and M. Leib, ”Hybrid Quantum-Classical Multi-Agent Pathfinding,” arXiv
preprint arXiv:2501.14568, 2025.

[15] E. Osaba, P. Miranda-Rodriguez, A. Oikonomakis, M. Petrič, A. Ruiz, S. Bock, and M.-A. Kourtis,
”Solving Drone Routing Problems with Quantum Computing: A Hybrid Approach Combining
Quantum Annealing and Gate-Based Paradigms,” arXiv preprint arXiv:2501.18432, 2025.
[16] E. Davies and P. Kalidindi, ”Quantum Algorithms for Drone Mission Planning,” arXiv preprint
arXiv:2409.18631, 2024.

[17] T. Śmierzchalski, J. Pawlowski, A. Przybysz, L. Pawela, Z. Puchala, M. Koniorczyk, B. Gardas, S.

Deffner, and K. Domino, ”Hybrid Quantum-Classical Computation for Automatic Guided Vehicles
Scheduling,” arXiv preprint arXiv:2309.03088, 2024.

10