Quantum Heuristic Approach to Vehicle Routing Problem

Abstract

Quantum optimization has recently drawn considerable attention as one of the possible applications of noisy intermediate-scale quantum computation, yet the problem of qubit requirement remains a major bottleneck when combinatorial optimization problems are converted into quantum circuits. This issue becomes especially critical in solving the capacitated vehicle routing problem (CVRP) with the quantum approximate optimization algorithm (QAOA), since the number of required qubits increases polynomially with respect to the number of nodes. This study investigates whether a heuristic divide-and-conquer strategy can be adapted to the quantum setting so as to improve qubit efficiency while preserving the optimization capability to a reasonable extent. The proposed method decomposes a single CVRP into multiple traveling salesman problems (TSPs) by the sweeping-based clustering method, searches for the sector configuration with the smallest angle sum by Grover’s search algorithm, and then solves each sector-wise TSP with the QAOA aided by the gravitational search algorithm. Experiments on five benchmark datasets show that the proposed approach attains feasible solutions within 3.4 to 12.7% of the reinforcement-learning baseline on the main test set. These results suggest that the proposed approach serves as a plausible quantum heuristic framework for constrained routing optimization, with the advantage of reducing the qubit burden by decomposing the original problem into smaller subproblems.

1. Introduction

In spite of its relatively short history of advancement, quantum computing is now regarded as one of the most highlighted domains of research and investment in the field of information technology. How well quantum computers will be able to actually perform still remains mostly unknown, but their seemingly optimistic potential has been drawing attention in various areas of interest from the theoretical sciences, such as chemistry simulation, to the industrial applications, including quantum machine learning [1]. Indeed, a number of studies have been recently introduced as a series of preliminary attempts to apply the known quantum advantages to several real-world problems, and although the first arrival of fully functional quantum computers are yet to come, we deem that it is safe enough to state that the practicability of quantum algorithms has been partially, if not fully, proven [2].

It has long been anticipated that the computational abilities of machines powered by quantum mechanics could dramatically surpass those of the classical counterparts, but the eye-catching terms such as quantum advantage or quantum supremacy have rather recently spread widely, thanks to the current competitions among the tech giants. For example, Google’s initial claim of achieving the first verified quantum supremacy was quickly defied by IBM in 2019, arousing the worldwide curiosity upon the controversial topic [3]. Apparently, the ongoing attention on quantum computing is largely due to the anticipation that it could provide with new approaches to handle the extremely large and complex problems, for which classical computers are generally considered either incapable or ineffective [4].

Devising quantum-intrinsic algorithms is a difficult task, since the logical systems behind quantum and classical circuits differ to a great extent. Even in the case of simple operations such as the basic arithmetic, it can be evidently shown that the quantum circuit is wired in a way that the classical circuit barely resembles [5]. Therefore, it has been a popular practice in the field of quantum computing to imitate the operational structure of the known, validated classical algorithms and reproduce their processes under the quantum rules. Quantum machine learning, quantum reinforcement learning, and quantum genetic algorithms are only a few well-known examples, not to mention a lot more of them throughout multiple domains of research in computer science.

Our study introduced in this paper is a contribution to the contemporary efforts of developing quantum algorithms, inspired by and based on the classically structured and functioning algorithms, that are intended to be applicable to real-world problems through which their practicability and feasibility could be verified with reasonable bench-marking. Specifically, we mainly focus on replicating the process and advantages of a heuristic optimization strategy upon a quantum computation structure to solve spatially large and complex optimization problems such as the capacitated vehicle routing problem (CVRP), which is the target of our choice in this study.

Decomposing a larger problem into smaller sub-problems is one method of the heuristic approach that can often simplify the given task. One could turn this fact to good advantage by removing the “dead-weight” factors, such as constraints in the constraint optimization problems, while keeping the increase in the algorithm’s overall complexity at bay. Our proposed approach is an attempt to examine whether imitation of a heuristic, divide-and-conquer model in a quantum computing environment could improve its computational effectiveness as an optimization problem solver, as well as to foster comparably economic use of quantum resources including qubits, the quantum version of bits.

The CVRP is one of the crucial and traditional archetypes of the combinatorial optimization problems. It is a broader, or generalized, traveling salesman optimization problem that involves a number of travellers with constraints, such as cargo weight, for all of which the optimal paths are sought [6]. Reversing the aforementioned notion, our intention is to decompose a single CVRP into several TSPs and resolve each individually with quantum computation. In detail, we exploit several quantum techniques, such as Grover’s search algorithm and the quantum approximate optimization algorithm, in an attempt to effectively divide the search space into smaller sectors and to solve the transformed TSPs individually.

This paper contains the following structure. In Section 2, we will briefly review the related studies on similar topics. In Section 3, the background information on quantum computing and several necessary techniques is introduced to help readers comprehend the theoretical aspects of this study. In Section 4 and Section 5, we thoroughly explain the proposed approach and share its experiment results. In Section 6, we make an analysis on the results, and we close the paper with conclusion in Section 7.

2. Related Literature Review

Quantum optimization is one of the major research branches of quantum computing, and many studies have already been introduced with regards to real-world applications, including the subject of path-finding problems presented by the TSP and VRP. In this section, we introduce a few noteworthy examples that we consider are relevant to our study. It is regarded that quantum optimization can be achieved via both the annealing-based and the circuit-based paradigms [7]. Here, we particularly focus on the circuit-based approaches that suit our research direction.

Apparently, the idea of performing optimization with quantum computation was not proposed by a single, distinct work. It was rather derived from the common belief among many that quantum computing, noted with its theoretically known advantages, could improve the computational efficiency in terms of both time and space. Nonetheless, it is generally recognized that Grover’s search algorithm in 1996 marks an exceptional impact upon countless successive studies across numerous domains, and quantum optimization is no exception [8]. The main contribution of Grover’s algorithm to effectively find an item out of an unordered data list appears to be highly applicable to various optimization techniques, and various works devoted to quantum optimization admit that their methods either adopt or are inspired by Grover’s algorithm [9]. In fact, the quantum algorithms for minimum and maximum searching, which are often an important task in optimization, are largely based on the methodology proposed by Grover [10,11].

The recent advancement in building actual quantum processors has widened the understanding of physical limitations as well, implying that fully functional quantum computers still require a substantial amount of time before realization. It was thus proposed that advancement of the noisy intermediate-scale quantum (NISQ) era must be taken into account [12]. The most distinctive feature of the NISQ algorithms is their classical–quantum hybrid structure, where both classical and quantum algorithms are run one after the other to complete a given task. One of the most well-known NISQ algorithms is the quantum approximate optimization algorithm (QAOA) [13], which is also introduced and applied in this study.

There have been multiple approaches proposed with regards to solving the VRP and TSP with quantum computation, where they are often referred to as the quantum VRP (QVRP) and quantum TSP (QTSP). Specifically, these studies have investigated circuit-based quantum approaches for solving routing problems directly. Harwood et al. in 2021 described a series of mathematical optimization models, along with their pros and cons, that are specially designed to solve the QVRP with time windows [14]. In addition, Fitzek et al. and Azad et al., in 2021 and 2022, respectively, presented their evaluations on utilizing the QAOA to solve the QVRP. They reached similar conclusions, noting that the QAOA is reasonably applicable to combinatorial optimization algorithms including the QVRP [15,16].

Some later studies adopted a two-phase or decomposition-based strategy in an attempt to solve the CVRP more effectively. The key concept is to decompose the original problem into multiple sub-problems and treat one after the other, aiming to compromise the lack of computational resources by the current hardware constraints. For example, Palackal et al. demonstrate the method of reducing a CVRP to a set of TSPs by modeling it as a multiple knapsack problem and distributing customer locations accordingly [17]. One other study by Herzog et al. proposes exploitation of a graph-shrinking method, which is devised to partition the problem graph heuristically for clustering purposes [18]. Additionally, Feld et al. and Borowski et al. introduce a number of algorithms that extensively utilize the process of quantum annealing [19,20].

A number of studies focused on improving the quality or feasibility of circuit-based route optimization itself. Some of them suggest use of Quantum Alternating Operator Ansatz on the matter, which is a variant of the QAOA and often abbreviated as AOA. For example, Xie et al. argue in their study that adopting AOA instead of QAOA leads to significantly increasing the solution’s feasibility and observation probability [21]. A paper by Hadfield et al. introduces a technique to better present the TSP-related constraints by selectively representing permutation matrices via superposition [22], while Bärtschi et al. propose an initialization method that improves the results by generating a uniform superposition over all such states [23]. In addition, the survey by Gemeinhardt et al. published in 2023 presents a detailed review of various quantum applications to combinatorial optimization problems [24].

Despite the preceding efforts, relatively little has been explicitly discussed on constructing a unified circuit-based quantum framework that addresses both the decomposition and routing steps for the CVRP. A number of existing studies, introduced above, either focus on the routing problem after a pre-defined clustering process or rely on quantum annealing-based approaches rather than circuit-based methods. In addition, the problem of reducing qubit burden by heuristically decomposing a single CVRP into smaller sub-problems, while preserving the optimization capability to a reasonable extent, has not been sufficiently examined. The main purpose of this study is to address this gap by proposing a quantum divide-and-conquer framework that transforms a single CVRP into multiple sector-wise TSPs, adopts Grover’s search algorithm to determine the sector configuration, and solves each resulting TSP by the quantum approximate optimization algorithm aided by the gravitational search algorithm. Through this structure, this study aims to examine the feasibility of a qubit-efficient heuristic optimization framework for constrained routing problems.

3. Quantum Computing Preliminaries

In this section, we briefly explain the foundational elements, including quantum computing and quantum information, that could help comprehend the context of our study. For the quantum-related parts, since they are discussed here in a relatively concise manner, readers are encouraged to refer to [2,4] for further readings that will provide all the necessary details.

3.1. Qubit and Quantum State

Qubit is a quantum analog of bit in a conventional computer, which acts as a basic data block. Unlike a bit, a qubit can represent the values of 0 and 1 simultaneously if a proper operation is applied to it. In terms of quantum physics, this phenomenon of superposition is more complex than it appears, since what actually coexist are their probability amplitudes, not the presence of the values themselves. In the literature on quantum computing in general, however, it is often described as mere possessing of two different values at the same time for the sake of simplistic explanation.

Any process of quantum computation can be written entirely with the linear algebraic description. A quantum state $|\psi ⟩$ of a qubit, basically a specific vector representation in a Hilbert space, is written as

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩=\alpha \left[\begin{array}{c}1\\ 0\end{array}\right]+\beta \left[\begin{array}{c}0\\ 1\end{array}\right]$$

(1)

which is called the state vector representation. $\alpha$ and $\beta$ are the probability amplitudes of $|0⟩$ and $|1⟩$, respectively, constituting the square root of their relative probabilities for observation after measurement. Therefore, ${\alpha }^2+{\beta }^2=1$ holds. A quantum state of multiple qubits can be written with the tensor product.

$$\begin{array}{c}\hfill |{\psi }_1⟩\otimes |{\psi }_2⟩=\alpha |00⟩+\beta |01⟩+\gamma |10⟩+\delta |11⟩\end{array}$$

(2)

Note that the number of simultaneously represented states above is 4, which is two raised to the power of the number of qubits. Indeed, the number of states increases exponentially with the number of qubits put into superposition to represent them. In other words, placing n qubits into equal superposition enables representing at most $2^n$ quantum states.

A series of changes made to quantum states during quantum computation can be at the end turned into observables, and such jobs are done by quantum operators, which are generally in the form of a matrix gate. There are several important quantum operators frequently used for crucial calculations. The Hadamard gate H puts a qubit into superposition as shown in the following:

$$\begin{array}{cc}\hfill H|0⟩& ={\displaystyle \frac{1}{\sqrt{2}}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]\left[\begin{array}{c}1\\ 0\end{array}\right]={\displaystyle \frac{1}{\sqrt{2}}}\left[\begin{array}{c}1\\ 1\end{array}\right]\hfill \\ & ={\displaystyle \frac{1}{\sqrt{2}}}\left[\begin{array}{c}1\\ 0\end{array}\right]+{\displaystyle \frac{1}{\sqrt{2}}}\left[\begin{array}{c}0\\ 1\end{array}\right]\hfill \end{array}$$

(3)

The two states now share equal probability to be measured, i.e., 50%. Note that the Hadamard gate is unitary, i.e., $H^{*}H=H{H}^{*}=I$. In fact, every quantum gate is unitary in the sense that the quantum reversibility must be preserved as long as the system remains coherent. In terms of quantum mechanics, a quantum gate itself can be regarded as a Hamiltonian time evolution. Another important gate is the phase shift gate, which intrinsically takes the form of

$$P\left(\alpha \right)=\left[\begin{array}{cc}1& 0\\ 0& e^{i\alpha }\end{array}\right]$$

(4)

which changes the relative phase of the $|1⟩$ component while leaving the computational-basis probabilities unchanged. In geometric terms, $\alpha$ corresponds to a rotation about the z-axis on the Bloch sphere shown in Figure 1. Such phase-based operations are important because interference among quantum states depends not only on amplitudes but also on their relative phases.

Figure 1. Bloch sphere with an arbitrary quantum state $|\psi ⟩$, marked as a red dot on its surface.

The phase shift gates generalize several notable quantum gates, including the Pauli-Z operator, which rotates the qubit state about the z-axis by $\pi$ radians. They are not Hermitian, and their application does not change the probability amplitudes of quantum states. Nonetheless, their role in quantum computing is significant and is vastly discussed in detail in relative studies.

Lastly, there is the measurement operator that marks the end of a certain process of quantum computation. The act of measurement collapses the quantum state, and in terms of quantum computing, it essentially transforms quantum information into classical information, which can be written with classical bits of 0 or 1. It probabilistically retrieves the information accordingly with the probability amplitudes of the superposed states, and the information of those not chosen is irreversibly lost. Quantum measurement lies between the quantum and classical systems, and is thus one of the most crucial concepts of quantum computing.

3.2. Quantum Search on Unordered Data Structure

The quantum unordered data search, widely known as Grover’s search algorithm, is designed to deliberately raise the probability amplitude of a desired state, which represents an item to pick, thereby increasing the chance to preserve it after wave function collapse at the measurement. In short, Grover’s algorithm iteratively performs the two-fold process of the oracle encoding and the Grover diffusion.

An oracle is an operator that “loads” a target problem into a quantum circuit. In other words, it prepares input data that the circuit’s main algorithm receives to operate with, including the desired state marked by the problem function. In the theoretical perspective, a quantum oracle is regarded as a black-box operation, since its actual implementation is often burdensome and thus omitted especially when it is less prioritized in terms of the scope of research. However, its usefulness lies on its capability to calibrate the theoretical complexity of the algorithm [25]. Depending on choice of the classical-to-quantum data encoding methods, the gate configuration of an oracle could vary. In implementing Grover’s algorithm, the oracle performs the basis encoding, i.e., translating real numbers into binary strings of 0 and 1.

What the oracle essentially prepares is a set of quantum states, each of which represents an item from an unordered data list. Since the qubits that form these states are put into superposition beforehand, the upper bound of the number of items is exponentially larger than the number of qubits loaded on the circuit to represent them. The states then proceed to the second step, the Grover diffusion, where their probability amplitudes are manipulated in pursuit of amplifying the marked state’s probability to a sufficient degree enough that it can be guaranteed to be observed after measurement. The Grover diffusion operates via two vector reflection processes, as shown in Figure 2. The number of iterations for Grover diffusion before attaining the desired item with high probability is analyzed as $\lceil {\displaystyle \frac{\pi }{4}}\sqrt{N}\rceil$ with N items in total, and this evaluation is the basis to the popular claim that Grover’s algorithm is quadratically faster than any known classical search algorithms [2].

Figure 2. Grover diffusion process. A quantum state vector $|\psi ⟩$ starts from equal superposition $|s⟩$ and rotates in the system’s Hilbert space by the two Grover reflection operators $U_s$ and $U_c$ with the reflective angle of $\theta$. The goal is to move $|\psi ⟩$ to $|c⟩$, the desired state.

Since its revelation in 1997, Grover’s search algorithm has been further investigated and improved in multiple studies, among which the Grover-BBHT algorithm is particularly worth mentioning. The original algorithm demands the predetermined number of solutions before searching, since its required number of iterations depends on how many states are to be marked by the oracle. The Grover-BBHT algorithm circumvents this flaw by iterating the entire algorithm itself accordingly with threshold updates. The asymptotic upper bound of the algorithm’s complexity is kept at the same level, allowing the authors to claim that the quantum advantage of the original algorithm remains preserved [26]. The Grover-BBHT algorithm has become the basis of the quantum minimum and maximum finding methods [11].

It is worth noting that, in problems such as the CVRP, the feasibility conditions are not naturally given as an unordered list to be searched, and thus the oracle must be constructed so that the target condition is represented in a circuit-compatible form. Depending on the encoding strategy, this process may require additional ancilla qubits, comparison circuits, and data-loading overhead, which can reduce the practical benefit of the algorithm. Partially due to this reason, Grover’s algorithm is not used in this study to solve the constrained CVRP directly. Instead, it is employed only for the limited task of selecting the sector configuration, which keeps the oracle-setting process simpler than the direct encoding of the original routing constraints.

3.3. Quantum Approximate Optimization Algorithm

Implementing the whole algorithmic procedure from the beginning to the end under a quantum system is, in a practical sense, a difficult goal to achieve. Building and operating quantum processors in the real world have already been faced with several physical limitations, including the problem of quantum decoherence [2]. Therefore, the idea of noisy intermediate-scale quantum (NISQ) machines emerged, seeking quantum–classical hybrid approaches in order to secure increased practicality of quantum implementation with partial adoption of classical computation. The quantum approximate optimization algorithm, or QAOA, is one of the NISQ methods proposed to perform quantum optimization with the aid of a classical optimizer.

The QAOA is classified as a variational quantum algorithm, for which a classical algorithm is used to gradually optimize a parameterized quantum circuit via multiple iterations [27]. The circuit is divided into two parts, the problem Hamiltonian and the mixer Hamiltonian. The problem Hamiltonian is where a problem is loaded, and the mixer Hamiltonian guarantees that the result of each computation step is reflected upon the states. With regards to solving an optimization problem with the QAOA, it is a conventional approach to first convert the problem into the form of quadratic unconstrained binary optimization (QUBO), which then can be regarded as an Ising model. The converted problem is loaded on the $R_Z$ gates as parameters inside the problem Hamiltonian, and each of these gates performs single-qubit rotation around the z-axis by degrees read from the parameters.

With a quantum state $|\left(x\right)⟩$ with x as a real-valued parameter, the task now is to minimize the expectation value of the total energy in the Hamiltonian H:

$$\begin{array}{c}\hfill C\left(x\right)=⟨\psi \left(x\right)|H|\psi \left(x\right)⟩\end{array}$$

(5)

Here, $C\left(x\right)$ is the expected cost value obtained from the state $|\psi \left(x\right)⟩$, and minimizing it is equivalent to searching for a state that approximates the ground state of the problem Hamiltonian H. In other words, the original combinatorial optimization problem is transformed into the task of finding the parameter setting that yields the lowest Hamiltonian expectation value.

To load a binary optimization problem into the Hamiltonian, the binary decision variable is mapped to the Pauli-Z operator by

$$\begin{array}{c}\hfill x_{i,t}\to {\displaystyle \frac{1}{2}}(1-Z_{i,t})\end{array}$$

(6)

where $x_{i,t}$ is the classical binary variable and $Z_{i,t}$ is the corresponding Pauli-Z operator acting on the qubit assigned to that variable. Through this mapping, the classical cost function can be rewritten in an operator form and treated as a quantum Hamiltonian. Additionally, the Pauli-Z operator has the following relationship with the rotation gate $R_z$:

$$\begin{array}{c}\hfill R_z\left(2\theta \right)=e^{-i\theta Z}\end{array}$$

(7)

The problem now has turned into finding ${\theta }^{*}$, the angle that minimizes the problem Hamiltonian’s expectation value. Additionally, the algorithm requires a proper angle for the mixer Hamiltonian, demanding two angle parameters $\gamma$ and $\beta$. Overall, the main objective is to find the minimum value possible for the expectation value of the problem Hamiltonian $H_c$, which is $⟨\psi (\beta ,\gamma )|H_c|\psi (\beta ,\gamma )⟩$. It can be achieved by attaining two optimized angle parameters for the following state:

$$\begin{array}{c}\hfill |\psi (\beta ,\gamma )⟩=U_m\left({\beta }_1\right)U_c\left({\gamma }_1\right)\cdots U_m\left({\beta }_p\right)U_c\left({\gamma }_p\right)|{\psi }_0⟩\end{array}$$

(8)

where $U_c=e^{-i{\gamma }_i{H}_c}$ is the unitary generated by the problem Hamiltonian $H_c$, $U_m=e^{-i{\beta }_i{H}_m}$ is the unitary generated by the mixer Hamiltonian $H_m$, and p denotes the number of alternating layers. The role of the classical optimizer is to search for the parameters ${\beta }_i$ and ${\gamma }_i$ that minimize $⟨\psi ({\beta }_i,{\gamma }_i)|H|\psi ({\beta }_i,{\gamma }_i)⟩$. Therefore, the QAOA can be regarded as a hybrid iterative procedure in which the quantum circuit evaluates candidate parameters and the classical optimizer updates them.

It should be noted that the NISQ framework does not eliminate the physical limitations of actual quantum computation. Diverse factors such as noise accumulation and circuit-depth sensitivity remain substantial obstacles in practical optimization tasks. In particular, when a combinatorial problem is loaded by a direct QUBO-type encoding, the number of required qubits and the depth of the corresponding circuit may increase rapidly with the problem size, and the resulting computation may become vulnerable to error explosion. Therefore, decomposition of the original problem into smaller sub-problems introduced in this study should not be interpreted as a complete resolution of the NISQ limitations but as a heuristic strategy that may alleviate the qubit burden of each routing sub-problem at the cost of additional pre-processing and route-combination steps.

3.4. Gravitational Search Algorithm

The QAOA requires a classical optimizer to find suitable parameters for the circuit gates. The optimizer selected in this study is the Gravitational Search Algorithm (GSA), a classical optimization technique inspired by the gravitational laws of nature [28]. Among the numerous optimization techniques available in the literature, the GSA was chosen for the following reasons. First, the parameter set to be optimized in the QAOA consists of continuous-valued rotation angles, and the GSA is known to be suitable for optimization in a continuous search space [29]. Second, the expectation-value landscape returned by a variational quantum circuit may contain multiple local optima, for which a population-based meta-heuristic approach is considered appropriate. Third, this study is primarily concerned with examining the feasibility of the proposed quantum heuristic framework rather than exhaustively tuning the classical optimization stage itself, and the structurally simple iterative mechanism of the GSA is suitable for such a proof-of-concept setting. Therefore, GSA was adopted as the classical optimizer for updating the QAOA parameters.

The main principle of the GSA is its methodological metaphor of the Newtonian law of gravitation, stating that the mass of an object is proportional to the gravitational force it exerts [30]. The algorithm starts with generating a set of agents, which are then to be constantly and iteratively repositioned in the search space, accordingly with their masses and the corresponding gravitational interactions among them. The mass of each agent $a_i$ is recalculated at the end of each iteration $t_j$, following the equation

$$\begin{array}{c}\hfill m(a_i,t_j)={\displaystyle \frac{fit(a_i,t_j)-worst\left(t_j\right)}{best\left(t_j\right)-worst\left(t_j\right)}}\end{array}$$

(9)

where $fit(a_i,t_j)$ is the agent’s fitness value at $t_j$. $best\left(t_j\right)$ and $worst\left(t_j\right)$ are the agents with the highest and the lowest fitness values at $t_j$, respectively. In other words, the mass of each agent constantly changes based on its interaction with the environment. The gravitational force,

$$\begin{array}{c}\hfill F_{ab}\left(t_j\right)={\displaystyle \frac{G\left(t\right)\left(M_a{M}_b\right)}{R_{ab}}}\end{array}$$

(10)

between each pair of agents with masses $M_a$ and $M_b$, apart by the distance of $R_{ab}$ under the gravitational constant $G\left(t\right)$, is then calculated to find their velocity and acceleration, which are

$$\begin{array}{c}\hfill a_a={\displaystyle \frac{F_{ab}}{M_a}}\end{array}$$

(11)

and

$$\begin{array}{c}\hfill v_a(t+1)=\mathrm{rand}X{v}_a\left(t\right)+a_a\left(t\right)\end{array}$$

(12)

respectively, with $rand$ as a random coefficient used to preserve stochastic exploration. The graphical representation of the mentioned process is shown in Figure 3. In this study, the position of each agent represents a candidate set of QAOA parameters, and the corresponding fitness is evaluated from the expectation value returned by the quantum circuit. The GSA then repeatedly updates the candidate parameter vectors so that the QAOA may gradually approach a lower-cost solution. The overall optimization procedure of the GSA as used in the workflow described above is summarized in Algorithm 1.

Figure 3. A 2D graphical abstract of a GSA agent relocated due to the gravitational effects from surrounding agents.

The concepts introduced in this section constitute the main computational elements of the proposed framework. In the following section, the CVRP is first formulated in a QUBO-compatible form, after which the sweeping-based clustering method is used to decompose the original problem into sector-wise TSPs. Grover’s search algorithm is then applied to select the sector configuration, while the QAOA and the GSA are jointly used to solve the resulting TSP in each sector. With these components combined, the next section presents the overall quantum heuristic approach in detail.

Algorithm 1 GSA-based optimization of QAOA parameters.
1:	Input: number of agents k, number of iterations g, QAOA layer number p, search ranges of $\beta$ and $\gamma$
2:	Output: optimized parameter vector (${\beta }^{*}$, ${\gamma }^{*}$)
3:	Generate k agents with random initial positions in the parameter space
4:	Assign each agent’s position to a candidate QAOA parameter vector
5:	Evaluate the fitness of each agent by computing the QAOA circuit expectation value
6:	for $t=1$ to g do:
7:	Find the current best and worst fitness values
8:	Compute the mass of each agent
9:	Compute the gravitational forces among the agents
10:	Compute acceleration and velocity
11:	Update the position of each agent in the parameter space
12:	Re-evaluate the fitness values of the updated agents
13:	end for
14:	Return the parameter vector of the best agent

4. Quantum Heuristic Approach

In this section, we introduce the proposed approach to achieve quantum optimization with a heuristic method as to the task of solving the VRP, based on the theoretical foundations introduced previously. The following principal notations may appear throughout the section and are recommended to be referred to for full comprehension.

4.1. Problem Formulation

A few studies on quantum optimization theory have introduced the adaptation of the QAOA on solving combinatorial optimization problems with notable results, but little has been addressed with regards to the number of required qubits to actuate their simulation methods. This issue is especially critical when converting a VRP instance into an Ising form for the problem Hamiltonian of the QAOA, since the number of required qubits is at least a polynomial of the number of the total nodes squared, or, more specifically, $n\times (n-1)$ where n is the number of nodes [16]. While increasing computational efficiency is one important goal of developing quantum algorithms, regulating the number of utilized qubits to a reasonable extent is also a crucial factor, considering the coherence and result accuracy of the algorithm [31]. The choice of framework for the approach proposed in this paper is to decompose the VRP with the sweep method into several sub-problems that are represented as the TSPs, and the main motivation is to investigate whether such a framework could provide an aid to the current attempt of developing qubit-efficient quantum algorithms.

The TSP in a general form can be described as a linear program with the objective function

$$\begin{array}{c}\hfill \mathrm{minimize}\sum _i\sum _j{c}_{ij}{x}_{ij}\end{array}$$

(13)

where $c_{ij}$ is the distance between the destinations, or the nodes, i and j, with a binary decision variable

$$\begin{array}{c}\hfill x_{ij}=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}\mathrm{the}\mathrm{edge}\mathrm{between}i\mathrm{and}j\mathrm{is}\mathrm{chosen}\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.\end{array}$$

(14)

where $i,j\in \{0,\dots ,n\}$. On the other hand, we assume a VRP with the following formulation.

$$\begin{array}{cc}\hfill \mathrm{minimize}& \sum _i\sum _j{c}_{ij}{x}_{ij}\hfill \end{array}$$

(15)

$$\begin{array}{cc}\hfill \mathrm{subject}\mathrm{to}& \sum _{j\ne i}{x}_{ij}=1,\hfill \end{array}$$

(16)

$$\begin{array}{cc}\hfill & \sum _{i\ne h}{x}_{ih}-\sum _{j\ne h}{x}_{hj}=0,\hfill \end{array}$$

(17)

$$\begin{array}{cc}\hfill & \sum _{j=1}{x}_{0j}\le K\hfill \end{array}$$

(18)

where $i,j,h\in \{0,\dots ,n\}$. The equations above represent a conventional VRP with capacity constraints, often abbreviated as CVRP. Equation (15) dictates the objective function to minimize the total distance of the chosen route. An additional continuous decision variable $y_j$ is introduced to represent the cumulated demand on the route that visits node j up to this visit. Equation (16) ensures that all customers are visited exactly once, and Equation (17) guarantees the correct flow of vehicles through the arcs by stating that if a vehicle arrives at h, then it must depart from the same node. Equation (18) limits the maximum number of routes to K, the number of vehicles. With regards to the capacity constraints, the followings conditions prevent the vehicle capacity from exceeding beyond the limit.

$$\begin{array}{c}{y}_j\ge y_i+q_j{x}_{ij}-Q(1-x_{ij}),\end{array}$$

(19)

$$\begin{array}{c}{d}_i\le y_i\le Q\end{array}$$

(20)

where $q_j$ is the demand of node j, Q is the maximum vehicle capacity, and $d_i$ is the lower bound associated with the demand variable. Equation (19) propagates the cumulative load along a chosen route, while Equation (20) ensures that the load variable remains within the feasible capacity range. Together, Equations (15)–(20) form the CVRP model considered in this study.

While several methods have been proposed to convert the cost function of the CVRP to QUBO, the most widely chosen is to encode based on sequential decision along the edges. A fully connected, undirected graph can be described by a cost matrix, for which each element $c_{ij}$ in the ith row and the jth column represents the required cost to move from the node i to the node j. With it, the corresponding QUBO can be written as

$$\begin{array}{cc}\hfill C(x)=& D(x)+A({\displaystyle \sum _t}{(1-{\displaystyle \sum _t}{x}_{i,t})}^2+{\displaystyle \sum _t}{(1-{\displaystyle \sum _t}{x}_{i,t})}^2)\hfill \\ \hfill & +B({\displaystyle \sum _i}{d}_i{\displaystyle \sum _t}{x}_{i,t}{-Q)}^2\hfill \end{array}$$

(21)

where

$$\begin{array}{c}\hfill D\left(x\right)=\sum _{i,j}{w}_{i,j}\sum _t{x}_{i,t}{x}_{j,t+1}\end{array}$$

(22)

is the total distance traveled by the vehicle along a path of edges with weights $w_{i,j}$, each lying between a pair of nodes. Whether they are considered in the corresponding path is represented by binary variables $x_i$ and $x_j$ (Figure 4). t is a discrete variable of time frame, indicating along with $x_i$ and $x_j$ on which node the vehicle is present at a certain point of time. The second and third terms refer to the ”only-one-customer” and capacity constraints, respectively, with arbitrarily set penalty weights $A,B\gg 1$.

Figure 4. An example of 3-node TSP.

The TSP and VRP are generally both considered as NP-hard, implying that verification of candidate solutions cannot be performed in a polynomial time with respect to the problem’s size. Adaptation of heuristics is therefore popular in both fields, and, for the same reason, the QAOA has been extensively exploited in related studies. Though they fall into the same class of complexity, given the same search space $G=(V,E)$, where V and E are sets of vertices and edges, respectively, the VRP is considered more difficult to find the optimal or pseudo-optimal solutions due to the additional constraining factors. In fact, as the authors point out in [32], the VRP can be specialized to the TSP by removing or simplifying its constraints. Consequently, the two-step idea of decomposing a single VRP into multiple TSPs and solving them individually appears valid in terms of reducing the computational complexity, and, in addition, it can also contribute to alleviating the burden of massive qubit usage in utilization of the QAOA for solving combinatorial optimization problems, as we argue here.

The decomposition strategy of VRP-to-TSP provides a reasonable means to decrease the problem size to consider one at a time. Given a CVRP as a fully connected graph $G=(V,E)$ with $N_v$ and $N_e$ as the numbers of vertices and edges, respectively, one can set a hyperparameter s that rules the number of sectors after partitioning the entire graph. This process neglects the configuration of the edges and is only performed with respect to the vertices that correspond to the nodes to visit. The mean value for the number of nodes in a single sector is therefore $N_v/s$, and the edges that lay between every pair of the sectors can be disregarded, since it is assumed that each sector is allocated to an individual vehicle. Every sector is now a smaller, separate graph $g_i$ with the numbers of its nodes and edges $n_{vi}$ and $n_{ei}$, respectively, whose edge layout remains unchanged from the original graph G.

Preceding quantum studies on the two-step CVRP decomposition show that the clustering technique substantially contributes to reducing the amount of computational resources required for the TSP-solving quantum subroutine. For example, ref. [18] claims that decomposition reduces the number of qubits required to configure the circuit design to one-fifth. With regards to our study here, the main concern is to inspect whether the clustering phase could also be performed with quantum computation, as well as the latter step of solving TSPs, especially in the aspect of circuit-based quantum computing. Ref. [17] implies that its proposed approach also consists of a quantum-processed clustering phase, but a detailed procedure of adapting and implementing it in the context of solving a CVRP based on decomposition is not explicitly discussed. We intend to design both steps quantum computationally to actually solve a CVRP and present that the decomposing method of our choice achieves a similar effect of reducing qubit usage and that it suits as a notable means of VRP-to-TSP transition among others.

The proposed framework is based on the following assumptions. First, each CVRP instance is represented as a fully connected and undirected graph, and the travel cost between two nodes is assumed to be deterministic and known in advance. Second, the problem is assumed to consist of a single depot, customer nodes with fixed spatial coordinates, deterministic demand values, and a given maximum vehicle capacity. Third, the decomposition is assumed to generate sectors whose total demand does not exceed the capacity limit, allowing the capacity constraint of the original CVRP to be handled mainly at the clustering stage. These assumptions are introduced in order to focus on examining the feasibility of the proposed quantum heuristic framework under a simplified but representative CVRP setting.

4.2. Sweeping-Based Clustering

Application of the sweeping cluster to solving the CVRP has been examined by a number of precedent studies in the realms of classical computing, some of which are introduced and analyzed by Akhand et al. [33]. Given a problem of CVRP, the method assumes the depot as the center of the search space as a circle, with which a corresponding polar angle is assigned to each node. The process of sectionizing the search space can then be regarded as dividing a circle, with the depot as a center point, into a set of sectors each possessing nodes accordingly with the given constraints, which, in the case of the CVRP, are the vehicle capacity and the logistic demand from each node (Figure 5). In other words, the sectors are formed in a way that the total amount of logistic demands in each sector does not exceed the vehicle capacity, guaranteeing that the vehicle is allowed to visit every single node in each sector without the risk of exceeding its capacity limit. In this design, the original problem of CVRP is now transformed to solving multiple TSPs, represented as the sectors, separately.

Figure 5. An example of the sweeping method on a VRP with 10 nodes, with the vehicle capacity of 20. Each arc indicates a sector that is formed accordingly with the problem constraints.

The search space in the aforementioned setting can be interpreted as a two-dimensional real vector space. In order to justify using the sweeping method in pursuit of the original task to minimize the vehicle routing distance, we introduce the following theorem.

Theorem 1.

Suppose that $G^{*}$ is a set of sectors $S_i,i\in \{0,\dots ,n\}$ with their corresponding angles ${\theta }_i$ such that ${\sum }_{i=1}^n{\theta }_i$ is smaller than that of any other possible set G′ in the given search space. Let $L\left(G\right)$ be a function that returns the total distance of the route generated by the sectors in G. Then, $\mathbb{E}\left[L\left(G^{*}\right)\right]\le \mathbb{E}\left[L(G\prime )\right]$ holds.

Proof of Theorem 1.

Assume two sectors $S_1$ and $S_2$, where ${\theta }_1={\theta }_2$ and an external node u exists between them. Assigning u to either of those sectors would not violate the capacity constraint. $S_1$ has a node $v_1$ that lies on its borderline closer to u so that an angle $a_1$ between the borderline and the vector form of u ($\overrightarrow{u}$) exists. The same goes for $S_2$ as well (Figure 6). If one assigns u to $S_1$, the minimum spanning tree (MST) of $S_1$ will increase by

$$\begin{array}{c}\hfill min\left\{uw\right|w\in S_1\}\end{array}$$

(23)

In most cases, it is expected that $w=v_1$. With a sufficiently large CVRP problem given, one can assume that the nodes in both sectors are uniform-randomly scattered so that the difference in the vertical component of $v_1$ and $v_2$ can be statistically disregarded. If $a_1\le a_2$, one then can claim that

$$\begin{array}{c}\hfill \mathbb{E}\left[min\left\{uw\right|w\in S_1\}\right]\le \mathbb{E}\left[min\left\{uw\right|w\in S_2\}\right]\end{array}$$

(24)

With the Beardwood–Halton–Hammersley Theorem [34], which shows that both quantities of TSP and MST on independently and identically distributed points scale similarly, it is guaranteed that the same inequality also holds for the case of TSP in our matter.    □

Figure 6. A node u exists between two sectors $S_1$ and $S_2$. If $a_1+{\theta }_1\le a_2+{\theta }_2$, it is expected that assigning u to $S_1$ would lead to generating a shorter TSP routing distance.

Considering the required transition to QUBO for implementing QAOA, the proposed approach of two-step decomposition can be advantageous to reducing the number of qubits needed to implement the algorithm. Suppose that there are $N_{node}$ nodes in the entire search space with the vehicle capacity C and the total customer demands combined as D. Then, the number of generated sectors by the sweep clustering method has the lower bound of

$$\begin{array}{c}\hfill n_{sec}=\lceil {\displaystyle \frac{D}{C}}\rceil \end{array}$$

(25)

The expected value for the number of nodes in each sector can be written as

$$\begin{array}{c}\hfill \mathbb{E}\left(n_{node}\right)={\displaystyle \frac{N_{node}}{n_{sec}}}={\displaystyle \frac{N_{node}}{\lceil D/C\rceil }}\end{array}$$

(26)

In other words, we can expect that with decomposition, the number of nodes to consider one at a time can be at least reduced by the factor of $\lceil D/C\rceil$ in average. The actual number of nodes in each sector would be more precisely traceable especially in larger, complex problems, where it is expected that $D>>C$, thus leading to $\lceil D/C\rceil \approx D/C$.

It is rather illogical to state that $N_{node}>n_{node}$ for any sector due to the fact that n could only be smaller by a factor of an arbitrary integer. Since, however, the basic QAOA encoding technique, referring to the QUBO in (21) and the binary decision variable in (14), requires $n^2$ qubits to represent the visit to n nodes via n sequences [27], the difference could be significantly larger depending on the size of the problem. In the real world, the vehicle capacity is constrained by the physical limitation of automobiles, implying that for a sufficiently large problem, it is safe to assume that $n_{sec}>n_{node}$, i.e., $n_{sec}=c{n}_{node}$ with a constant c. Let $f\left(n_{node}\right)={\left(c{n}_{node}\right)}^2$ and $g\left(n_{node}\right)=n_{node}^2$. One then can find arbitrary functions $p\left(n_{node}\right)$ and $q\left(n_{node}\right)$ that satisfy

$$\begin{array}{c}\hfill p\left(n_{node}\right)\le {\displaystyle \frac{f\left(n_{node}\right)}{g\left(n_{node}\right)}}=c^2\le q\left(n_{node}\right)\end{array}$$

(27)

since c will increase indefinitely with respect to the problem size, in which case it can be stated that $f\left(n_{node}\right)$ is polynomially larger than $g\left(n_{node}\right)$. Even in cases that the difference is not as much, one can still expect considerable reduction in the number of required qubits to configure the needed QUBO.

As an improvement over the conventional setup, ref. [35] claims that the number of qubits for each TSP can be reduced to ${(n_{node}-1)}^2$ with a fixed starting point method, although it assumes that the traveler does not return to the starting point. Meanwhile, ref. [36] introduces an encoding technique that allows to encode a function with $n_{node}log{n}_{node}$ qubits as HOBO. We anticipate that exploitation of our proposed method could further be enhanced by adopting these tactics.

4.3. Algorithmic Procedure

As the name of the decomposition strategy suggests, the whole procedure is divided into two sequential parts. First, a set of feasible sector configurations is generated by the sweeping-based clustering method, and Grover’s search algorithm is applied to select the configuration whose total sector-angle sum is the smallest. Second, after the sector configuration is fixed, each resulting sector is treated as an independent TSP and solved by the QAOA with parameter optimization by the GSA. Therefore, Grover’s search and the QAOA are not used in an alternating manner within a single optimization loop; rather, the former is used first for sector-configuration selection, and the latter is applied afterwards to the selected sector-wise routing problems.

The initial VRP data is assumed to consist of the x and y coordinates and the demand value of each node, including the point of origin, as well as the maximum capacity of the vehicles. The first task is to juxtapose a series of possible sector combinations differed by sweep-starting points. Configuration of sectors, including their number and size, for a VRP instance can vary depending on which node the sweeping starts with (Figure 7). The possible number of combinations thus equals the total number of nodes, and the goal is to specify the combination case where the sector angle sum is minimized. This approach has already been discussed in numerous studies, but rarely addressed is the viability of applying quantum computation to not only solving a TSP in each cluster but also decomposing the original problem as well. Since part of our purpose in this study is to examine to which extent the CVRP can be solved with quantum application, the decomposition step of finding the smallest combination case is designed to exploit Grover’s search algorithm.

Figure 7. An example of a VRP with 10 nodes distributed to 4 sectors, differentiated with distinct colors. The clockwise sweeping process starts at the node with $c=3$, meaning that its capacity demand is 3. A node is assigned to a new sector if the constraint limit of $c=10$ has been met.

There are on-going debates on the actual practicability of Grover’s algorithm and its variants. One of the major concerns is about the encoding problem, stating that the amount of computational resources required to prepare and encode data into the algorithmic circuit could be larger than the amount expected to be saved by the algorithm’s comparable quantum speedup [37]. Relatively optimistic studies argue that introduction of quantum random access memory (QRAM) could resolve the matter [38], although it has not been physically implemented yet. Since it is outside the scope here, we do not intend to further discuss the algorithm’s contribution to the proposed method’s computational efficiency. Instead, we focus on arranging it as part of an operable quantum algorithmic structure to solve the CVRP.

Given a CVRP with n nodes in total, n different sector configurations can be generated, as aforementioned. The task is to find a single configuration for which the sum of all the involved sector angles is the smallest among others. To achieve it, all the possible configurations are listed along with their corresponding angle sums and allocated indices. Since the search is to be performed with a quantum algorithm, the list is encoded to a quantum circuit with qubits, with the values as binary strings. Two quantum registers, representing the index (key) and the angle sum (value) of each configuration, are prepared, upon which the quantum search proceeds.

With n configurations to encode, one needs at least ${log}_{2}n$ qubits in the key register. For the angle sum, note that the angle values do not need to be explicitly encoded to represent their exact values; rather, being capable of telling their comparative differences would suffice. This can be performed by listing the values in order and converting them into consecutive binary strings. Therefore, one would also need up to ${log}_{2}n$ qubits to stack the value register, making the total number of qubits required to encode data $O\left(\lceil {log}_{2}n\rceil \right)$. A few more auxiliary qubits are needed for various purposes, including building the quantum oracle and the Grover’s diffuser, but their number does not grow proportionally with the size of the given problem or its data. After a series of iterations to allow Grover’s search, the circuit returns the index number of the desired combination, which then can be decoded back to an integer (Figure 8).

Figure 8. A quantum circuit that implements Grover’s search on the sectoral configurations.

Now that the nodes have been distributed to the sectors, the constraint factors of the original problem can be disregarded, and the only task left is to solve the TSP in each sector and to combine the solutions together at the end. Each sector’s information, comprising the nodes’ coordinates and the distances among them, is converted to the QUBO cost function

$$\begin{array}{c}\hfill C(x)=D(x)+p(\sum _t{(1-\sum _t{x}_{i,t})}^2+\sum _t{(1-\sum _t{x}_{i,t})}^2)\end{array}$$

(28)

Note that compared to (21), the demand and capacity constraint terms are now removed. This can be directly converted to the QAOA’s problem Hamiltonian form as in (5), and the task is then reduced to finding the minimum expectation value of the total energy in the system. The process of optimization is performed by the GSA iteratively, resulting in the optimized values for the rotation gate parameters on the circuit. The same procedure is performed on each sector, and at the end, a set of the optimal paths is secured.

The final operation is to concatenate the TSP solutions into a single path as a solution for the original VRP. While this part is crucial in terms of resulting in a complete solution, it is a relatively marginal priority with regards to the main scope of our work. We therefore chose the simple nearest selection method, which connects two adjacent paths by the two closest nodes from each. Algorithm 2 lists in order the necessary steps to implement the proposed method.

As a simple numerical example, consider a small CVRP instance consisting of one depot and four customer nodes, where the depot is located at (0,0), the customer nodes are located at $(1,2)$, $(2,1)$, $(-1,2)$, and $(-2,1)$, and each customer has unit demand under the vehicle-capacity condition $Q=2$. In this case, the sweeping method generates two feasible sectors, one including the two nodes on the right-hand side of the depot and the other including the two nodes on the left-hand side. For each candidate starting angle of the sweep, the corresponding total angle sum is calculated, and the set of sector divisions is encoded into the search space of Grover’s algorithm so that the division with the smallest angle sum may be selected. After the sector configuration is determined, each sector is treated as an independent TSP, and the corresponding route is encoded in QUBO form by the binary variables $x_{i,t}$, which indicate whether node i is visited at time step t. The QAOA with GSA-based parameter optimization is then applied to each sector-wise TSP, and the obtained routes are finally combined to produce the complete CVRP solution. Although simplified, this example illustrates the essential flow of the proposed framework, in which the original CVRP is first decomposed and then solved through sector-wise quantum route optimization.

Algorithm 2 Quantum Heuristic VRP Solver.
1:	Input: VRP data set consisting of n node coordinates and capacity constraints
2:	Output: Sector-wise divided, optimized VRP paths
3:	Generate A wheel table in dimension of ($n\times 2$) to contain arc combinations
4:	Encode the values of the wheel table into a quantum circuit
5:	Run Grover’s search algorithm $O\left(\sqrt{n}\right)$ times to identify the minimum arc angle combination
6:	while $(i<nu{m}_c)$ do: // $nu{m}_c$ = the number of sectors generated
7:	Initialize GSA population ← Generate k agents
8:	while $(i<g)$ do: // g GSA iterations
9:	Run QAOA to evaluate each agent’s fitness value // p parameter layers in the circuit
10:	Run GSA upon the agents
11:	end while
12:	end while

5. Computational Experiments

The main purpose of the experiment was to apply our proposed method to CVRP instances in various sizes and to measure the average number of qubits required for the overall procedure. The proposed quantum algorithm was developed and implemented with QISKIT (version 0.7.2), a Python-based quantum simulation and development kit published by IBM [39]. Prior to implementing the algorithm, we assumed a VRP instance consisting of the following features:

• Every node is connected with all the other nodes, i.e., the problem is visualized as a fully connected graph.
• Every vehicle shares the same maximum capacity, Q.
• The problem does not involve any time windows for nodes.
• The maximum number of nodes in a sector is limited to 5.

In other words, the target problem is a simplified form of the CVRP with the minimum number of constraints, designed specially to focus on verifying the proposed method’s capability to coup with an NP-hard problem. Since the main objective of this study is to suggest and validate a size-efficient quantum algorithm that can solve a problem with a considerably large size as to the number of available qubits at hand, the complexity features that are irrelevant to verifying the proposed method’s performance have been removed.

Generation of the VRP instances was fulfilled based on the procedure introduced in [40], with the varying number of nodes n ranging from 4 to 20. At the time of implementation, since the maximum number of qubits that could be simulated at once in QISKIT was 32, we arranged the problems in a way that, as noted above, each sector after division has up to 4 nodes only. This limitation is due to the aforementioned fact that the QAOA requires $n^2$ qubits to solve the TSP with n nodes. Since the CVRP must contain the initial starting point, the maximum number of nodes accounted for in each sector is $4+1=5$. Any sector that exceeds this number in size would require equal to or more than $6^2=36$ qubits, violating the QISKIT’s qubit limitation. The experiment was conducted upon 500 TSP instances, uniformly distributed along the size range.

With the considerably low computation speed of the simulated QAOA in concern, we set the GSA population size and the number of the QAOA parameters relatively low, as 20 and 8, respectively. During each iteration, whether the QAOA’s computation result satisfies the TSP configuration was determined, and if not, both of the values were increased, by 5 and 1, respectively, to encourage improvement over the quantum accuracy at the expense of the computational cost. The number of iterations for the GSA is set to 100, which is widely accepted in the related studies and also appropriate with regards to the population size.

The overall procedure of the experiment can be summarized as follows.

• A set of combination cases for the VRP division into sectors, varying with respect to the starting point, is prepared.
• The total sum of the sector areas in each case is calculated and converted into a binary string, ready to be encoded to the quantum system.
• Build a quantum circuit that implements the Grover’s search algorithm, by which the case with the smallest area can be specified.
• Within each sector of the selected case, run the GSA-based QAOA to find the shortest TSP path that starts from and comes back to the depot.
• Concatenate all the paths from the sectors and return them as single solution for the VRP.

In order to provide a basic yet fundamental evidence for functional comparability of the proposed method to the classical counterparts’ optimization performance, a classical CVRP solver based on reinforcement learning (RL) [41] was additionally implemented to solve the same problem set and to be compared with the quantum method with regards to the optimization outcome. Table 1 shows the lengths of the optimized paths constructed by the proposed algorithm, marked as QVRP, with respect to the given problem’s size, as opposed to the solutions obtained by the RL model. To ensure the solution feasibility, the algorithm was iterated 10 times for each CVRP instance, and the state that appeared most frequently with the highest probability amplitude was selected as a solution, based on which the optimized distance was calculated.

Table 1. Difference in performance of RL and QVRP on 5 VRP datasets.

Dataset	Algorithms	Optimized Distances
VRP4	RL	2.951
	QVRP	3.051
VRP8	RL	4.878
	QVRP	5.234
VRP12	RL	6.047
	QVRP	6.817
VRP16	RL	7.327
	QVRP	7.635
VRP20	RL	7.905
	QVRP	8.772

The algorithm’s design implies that any sufficiently large CVRP would require the number of qubits that exceeds the presupposed range of qubit usage at the preparation stage. To compensate for such deficiency, the sectors are further divided into smaller spaces to become solvable with the available number of qubits and then combined together at the end to attain the full path. The worst possible scenario is when the vehicle capacity is larger than or equal to the total demand from all the nodes in the problem, where now the CVRP is treated as a single TSP, with an exponential growth of the required amount of qubits.

The extra divisions of sectors are performed in the following procedure. First, set the node-limit parameter $n_{lim}$ and specify sectors that consist of more than $n_{lim}$ nodes. Second, divide the specified sectors into smaller subsectors that consist of $n_c<n_{lim}$ nodes. Third, the subsectors are applied with the identical process of the QAOA-based optimization to find the optimal path. Lastly, all the obtained paths are concatenated to complete the whole VRP solution. While this process would require additional vehicles, i.e., higher K in (18), since it is an independent, separate constraint, other constraints would remain affected. Figure 9 shows the graphical presentation of the aforementioned processes. An additional set of experiments was conducted on the datasets of VRP 6 and VRP 8 to verify the utility of the extra sector division, the results of which are listed in Table 2. Compared to the results in Table 1, it can be observed that the additional divisions of sectors hardly degenerate the optimization performance of the algorithm. On the contrary, it is shown that the proposed method outperforms RL on the dataset VRP 6.

Figure 9. An example of extra sector division. The blue sector, originally consisting of 5 nodes, has been divided into two smaller sectors each with its own path formed by blue and yellow arrows.

Table 2. Difference in performance of RL and QVRP with extra sector division.

Dataset	Algorithms	Optimized Distances
VRP 6	RL	3.831
	QVRP	3.595
VRP 8	RL	4.096
	QVRP	4.331

Although examining the subdivision method on all available CVRP instances would enhance the perceived credibility of our approach, its introduction is primarily motivated by the simulation limitations of Qiskit, which currently supports simulations of up to 32 qubits. This constraint, rather than considerations of performance or feasibility of our method, dictated the scope of our experimental evaluation. We contend that the results obtained on VRP 6 and VRP 8 are sufficient to demonstrate the general applicability of the method to larger CVRP instances, given that the TSP sectors are treated independently of the overall problem size.

The computational experiments in this study are intended to serve as a proof-of-concept validation of the proposed framework rather than as an exhaustive benchmarking study against all existing solvers. The benchmark instances were generated according to the procedure introduced in [40], and the comparison baseline was selected so that the same CVRP instances could be solved directly without the decomposition process, where the reinforcement-learning solver serves as a reference for functional comparability at the problem level. Direct numerical comparison with previously reported QAOA-based, quantum-annealing-based, or exact-solver-based studies would not be desirable, since the corresponding works differ in formulation, hardware paradigm, constraint setting, and benchmark construction. For this reason, the main purpose of the experiment in this study is to verify whether the proposed decomposition framework can preserve a reasonable optimization capability while alleviating the burden of qubit usage under the given simulation environment.

6. Discussion and Analysis

Compared with the preceding circuit-based studies that directly apply the QAOA or its variants to routing problems [15,16,21,22,23], the proposed framework is not primarily intended to improve the routing subroutine itself. Its main focus lies in reducing the effective problem size before the QAOA stage by decomposing a single CVRP into smaller sector-wise TSPs. On the other hand, the studies based on quantum annealing [19,20] belong to a different computational paradigm, and therefore their numerical results are not directly comparable to those of a circuit-based simulation under the NISQ setting. Accordingly, the significance of the experiments of this study lies less in absolute superiority of the obtained routing distances than in verifying the feasibility of the proposed qubit-efficient decomposition framework.

The main contribution of the work introduced in this paper breaks down to two points: efficient exploitation of qubits and suppressed computational complexity in implementation of heuristic optimization via quantum computation. Although we consider that the work’s major achievement is more associated with the former, we analyze the experiment results and the proposed algorithm’s theoretical contribution to it in both aspects here.

6.1. Qubit Requirement

Let $T_{Q_1}$ and $T_{Q_2}$ be random variables that correspond to the number of qubits exploited for sector division and each sector’s TSP computation, respectively. With n nodes in total, $T_{Q_1}$ can be written as

$$\begin{array}{c}\hfill T_{Q_1}=O(\lceil lo{g}_{2}n\rceil +(2\times \lceil lo{g}_2\theta \rceil )+1)\end{array}$$

(29)

$$\begin{array}{c}\hfill =O(\lceil lo{g}_{2}n\rceil +\lceil lo{g}_2\theta \rceil )\end{array}$$

(30)

$$\begin{array}{c}\hfill =O(\lceil lo{g}_{2}n·\theta \rceil \end{array}$$

(31)

where $\theta$ is a parameter to decide the degree of approximation for encoding the sector angles to the quantum circuit. The method assumes it equal to n as explained in Section 4.3, but even taking it as a real number C between 0 and 360,

$$\begin{array}{c}\hfill T_{Q_1}=O(\lceil lo{g}_{2}n\rceil +(2\times \lceil lo{g}_{2}C\rceil )+1)\end{array}$$

(32)

$$\begin{array}{c}\hfill =O(\lceil lo{g}_{2}n\rceil +C)\end{array}$$

(33)

$$\begin{array}{c}\hfill =O(\lceil lo{g}_{2}n\rceil \end{array}$$

(34)

$$\begin{array}{c}\hfill =\mathrm{\Theta }\left(lo{g}_{2}n\right)\end{array}$$

(35)

holds. On the other hand, $T_{Q_2}$ can be written as

$$\begin{array}{c}\hfill T_{Q_2}=\sum _{K=1}^n{Z}_k\sum _{i=1}^K{n}_c^2\left(i\right)\end{array}$$

(36)

where $n_c\left(i\right)$ is a random variable on the number of nodes in cluster i, and $Z_k$ is a random variable such that

$$\begin{array}{c}{Z}_k=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}K\mathrm{clusters}\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.\end{array}$$

(37)

holds. The information for each node can be represented with the traveler’s visit schedule and his/her current existence at the node. For example, if the TSP’s initial status is marked as a binary string of 1000, it indicates that the salesman is at the first node in the first time frame. Since the salesman has to visit every node once, the number of time frames equals the number of nodes. Taking expectation values from both sides, we have

$$\begin{array}{c}\hfill E[T_{Q_2}]=E[\sum _{K=1}^n{Z}_k\sum _{i=1}^K{n}_c^2\left(i\right)]\end{array}$$

(38)

$$\begin{array}{c}\hfill =\sum _{K=1}^{n}E[Z_k]·E[\sum _{i=1}^K{n}_c^2\left(i\right)]\end{array}$$

(39)

$$\begin{array}{c}\hfill ={\displaystyle \frac{1}{n}}\sum _{K=1}^{n}E[\sum _{i=1}^K{n}_c^2\left(i\right)]\end{array}$$

(40)

which then can be led to

$$\begin{array}{c}\hfill E\left[T_{Q_2}\right]={\displaystyle \frac{1}{n}}\sum _{K=1}^n{\displaystyle \frac{1}{K}}(n^2+{\displaystyle \frac{n^2}{2}}+{\displaystyle \frac{n^2}{3}}+\dots +{\displaystyle \frac{n^2}{K}})\end{array}$$

(41)

$$\begin{array}{c}\hfill \le {\displaystyle \frac{1}{n}}·{\displaystyle \frac{1}{n}}(n^2+{\displaystyle \frac{1}{2}}\left(2n^2\right)+{\displaystyle \frac{1}{3}}\left(3n^2\right)+{\displaystyle \frac{1}{n}}\left(n^3\right)\end{array}$$

(42)

$$\begin{array}{c}\hfill ={\displaystyle \frac{1}{n^2}}·n^3\end{array}$$

(43)

$$\begin{array}{c}\hfill =\mathrm{\Theta }\left(n\right)\end{array}$$

(44)

The number of required qubits for the entire algorithmic procedure $T_{tot}$ is therefore,

$$\begin{array}{c}\hfill T_{tot}=\mathrm{\Theta }\left(lo{g}_{2}n\right)+\mathrm{\Theta }\left(n\right)=\mathrm{\Theta }\left(n\right)\end{array}$$

(45)

Without implementing the additional sector division, the worst case, where a single sector consists of the entire VRP, would require the qubit requirement of $O\left(n^2\right)$. Nonetheless, we can also assume that in such a case the problem size is comparatively small, allowing a single vehicle to visit every node before coming back to the starting point.

6.2. Time Complexity

The proposed algorithm was designed as a practical quantum method, eligible to be run on an actual quantum machine that is fully capable of allowing superposition. Since the algorithm consists of gate-based parallel computation processes, evaluating the time complexity based on computational queries would not result in a fair analysis. Therefore, the time complexity analysis here is performed based on depth of the circuit built to implement the algorithm.

In Algorithm 1, Lines 1 to 3 contribute to generating a list of possible sector combinations and commencing Grover’s search algorithm. With QRAM, they would be estimated to require $O\left(n^2\right)$ and $O\left(\sqrt{n}\right)$, respectively [10]. Table 3 shows the depth of the Grover’s diffuser accordingly with the problem sizes. It is shown that the depth is constant, thus not increasing the overall time complexity.

Table 3. Grover search’s circuit depth with regards to the VRP size.

	VRP 4	VRP 8	VRP 12	VRP 16	VRP 20
Depth	7	7	7	7	7

Since the second part of the algorithm, the QAOA, is a heuristic procedure that is applied to the sectors separately, the amount of time required to perform it depends on the values of parameters set before it is run. The most important among them is p, the number of layers in the circuit that consist of the rotation gates that receive the angles retrieved from the classical optimizer, GSA. Its performance rate is highly relevant to the population size, which is decided with the number of agents k. In each iteration during g times of repetition, every interaction among all the agents is calculated, and generally it is presumed that $p\le k$. The calculation procedure for a single sector, and depth of a single layer in the QAOA circuit with regards to the number of nodes in the sector $n_c$ is as shown in Table 4.

Table 4. QAOA circuit depth with regards to the number of nodes in a sector.

	2 Nodes	3 Nodes	4 Nodes
Depth	9	19	33

The circuit depth appears to be proportional to $O\left(n_c^2\right)$, and thus the time complexity required for each sector becomes $O\left(n_c^{2}g{k}^2\right)$.

GSA has a structure similar to that of genetic algorithms (GAs) in terms of meta-heuristic optimization algorithms, and in particular, it can be compared to a GA that performs ordinal selection and uniform crossover. Roeva et al. [42] found that the size of the population that produces the most efficient optimization result for the number of repetitions of $g=200$ in the genetic algorithm is $k=100$, which means that the values of the population size and the number of repetitions in the meta-heuristic optimization algorithm are asymptotically the same. On the other hand, if $n_c$ is the number of nodes in the largest sector, the number of agents required then is generally proportional to $\sqrt{n_c}$, and since the number of nodes $n_c$ in the largest sector is proportional to the total number of nodes in a given VRP problem, it can be expressed as $k\propto \sqrt{n}$. This implies that $g\propto \sqrt{n}$ also holds for the same reason.

For the worst case, where one sector includes all the nodes of the entire VRP, $n_c=n$ and $k=1$ hold true. On the other hand, if the sector is divided into the smallest possible subsectors, then $k=n$ and $n_c=1$ hold true. However, since they are mutually exclusive and cannot occur at the same time, none of the cases significantly affect the time complexity. Furthermore, if the upper limit of the maximum number of nodes in each sector is set as an arbitrary parameter, it becomes a constant in the asymptotic notation. As a result, the total time complexity of the algorithm can be written as

$$\begin{array}{c}\hfill T_n=O(n^2)+O({\displaystyle \frac{n^{2}g{k}^2}{C}})=O(n^2+n^{2}g{k}^2)\end{array}$$

(46)

It is quadratically proportional to the number of nodes, which we argue is noticeably confined, especially with regards to the complexity of the target problem.

Note that the time complexity analysis above is based on a presupposition that the circuit is decomposed to the extent where each step of the oracle generation and Grover diffusion is counted as a single computational query. Such is a common practice in the related literature as to analyzing the computational efficiency of quantum algorithms that involve Grover’s search, and further decomposition of the circuit would alter the complexity in terms of the algorithm’s big-O expression. It is also worth emphasizing that the primary focus of this work lies in employing a heuristic strategy to efficiently decompose the CVRP into multiple TSP subproblems, rather than in enhancing the performance of the QAOA itself. Although the development of an effective and feasible QAOA implementation remains an important objective, our intention is to investigate whether improvements in the decomposition process can lead to enhanced overall optimization outcomes.

6.3. Sensitivity

The experiment results suggest that the proposed framework is sensitive mainly to the size of each sector and to the computational resources assigned to the optimization task. The maximum number of nodes allowed in a sector directly determines whether the corresponding TSP can be handled within the available qubit pool. This is the reason the additional sector-division procedure was introduced for the larger cases. As shown in Table 2, further subdivision does not severely deteriorate the optimization result and, in the case of VRP 6, even leads to acquiring a better result than the RL baseline. Additionally, the optimization outcome is related to the parameter budget of the hybrid solver. In the experiment, the GSA population size and the number of QAOA parameters were initially set to relatively small values in consideration of the simulation speed, and they were increased whenever the obtained state did not satisfy the TSP configuration. This indicates a trade-off between computational cost and route quality, which is a characteristic of the present hybrid framework.

The main benchmark results in Table 1 differ from the reinforcement-learning baseline by approximately $3.4$% to $12.7$%, depending on the dataset, while the extra sector-division results in Table 2 show a performance change of about $-6.1$% for VRP 6 and $+5.7$% for VRP 8, relative to the baseline values. These observations suggest that performance of the proposed framework is influenced by the level of decomposition yet remains reasonably stable in preserving feasible optimization performance under the imposed qubit limitation.

7. Conclusions

This paper introduces a quantum heuristic framework for solving the CVRP by decomposing a single problem into multiple sector-wise TSPs and solving them with the aid of Grover’s search algorithm, the QAOA, and the GSA. The main finding of this study is that a divide-and-conquer structure could contribute to providing a plausible way to reduce the effective problem size handled by the quantum routing subroutine, thereby alleviating the burden of qubit usage while preserving feasible optimization performance to a reasonable extent. The experimental results on the selected benchmark datasets show that the proposed method is capable of generating valid routing solutions with optimization outcomes that remained comparable to the reference baseline under the given simulation environment. In addition, the extra sector-division procedure suggests that further decomposition may maintain, and in some cases improve, the optimization result when the number of nodes in a sector exceeds the practically manageable range. The main merit of the proposed framework lies in its qubit-efficient problem decomposition under the circuit-based quantum-computing paradigm. Unlike approaches that focus only on the routing stage, it attempts to address both the sector-selection and the sector-wise route optimization phases within a unified quantum-oriented structure. The theoretical analysis further indicates that the decomposition strategy can be advantageous in terms of both qubit requirement and implementation complexity.

Admittedly, the proposed study has several limitations. The experiments were conducted under a simplified CVRP setting without time windows, a homogeneous vehicle-capacity assumption, and the practical restriction that the number of nodes in a sector had to remain within the 32-qubit simulation limit of Qiskit. In addition, the experimental comparison was limited in scale, and the obtained routing quality was affected by the current configuration of the QAOA-based optimization procedure. As a result, future research may proceed in several directions accordingly. First, the proposed framework may be extended to richer variants of the VRP involving additional operational constraints. Second, improved variational-circuit designs and alternative classical optimizers may be investigated to strengthen the sector-wise routing performance. Third, a broader validation on larger benchmark sets and actual quantum hardware would further clarify the practical applicability of the proposed approach.