Moderate Exponential-time Quantum Dynamic

Programming Across the Subsets for Scheduling

Problems
Camille Grange, Michael Poss, Eric Bourreau, Vincent T’kindt, Olivier Ploton

To cite this version:

Camille Grange, Michael Poss, Eric Bourreau, Vincent T’kindt, Olivier Ploton. Moderate Exponential-
time Quantum Dynamic Programming Across the Subsets for Scheduling Problems. European Journal
of Operational Research, 2024, �10.1016/[Link].2024.09.005�. �hal-04617682v3�

HAL Id: hal-04617682

[Link]
Submitted on 24 Sep 2024

HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est

archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents
entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non,
lished or not. The documents may come from émanant des établissements d’enseignement et de
teaching and research institutions in France or recherche français ou étrangers, des laboratoires
abroad, or from public or private research centers. publics ou privés.
 Moderate Exponential-time Quantum Dynamic Programming
Across the Subsets for Scheduling Problems∗

Camille Grange1,2 , Michael Poss1 , Eric Bourreau1 , Vincent T’kindt3 , and Olivier
Ploton3

1
University of Montpellier, LIRMM, CNRS, 161 rue Ada, Montpellier, France
2
SNCF, Technology, Innovation and Group Projects Department, 1 avenue François Mitterand,
Saint-Denis, France
3
University of Tours, LIFAT, 64 avenue Jean Portalis, Tours, France

Abstract
Grover Search is currently one of the main quantum algorithms leading to hybrid
quantum-classical methods that reduce the worst-case time complexity for some combina-
torial optimization problems. Specifically, the combination of Quantum Minimum Finding
(obtained from Grover Search) with dynamic programming has proved particularly efficient
in improving the complexity of NP-hard problems currently solved by classical dynamic
programming. For these problems, the classical dynamic programming complexity in
O∗ (cn ), where O∗ denotes that polynomial factors are ignored, can be reduced by a hybrid
algorithm to O∗ (cnquant ), with cquant < c. In this paper, we provide a bounded-error hybrid
algorithm that achieves such an improvement for a broad class of NP-hard single-machine
scheduling problems for which we give a generic description. Moreover, we extend
this algorithm to tackle the 3-machine flowshop problem. Our algorithm reduces the
exponential-part complexity compared to the best-known classical algorithm, sometimes at
the cost of an additional pseudo-polynomial factor.

keywords: Discrete Optimization, Quantum computing, Scheduling, Dynamic Program-

ming

1 Introduction

The fields of quantum computing and combinatorial optimization are becoming every day more
closely linked, thanks to the work of the quantum computing community, as well as the more
∗
This is an extension of the conference paper of Grange et al. (2023a).

1
recent interest of the operations research community that has been focusing on the new quantum
paradigm. More precisely, there are two types of quantum algorithms for solving optimization
problems. The first type encompasses heuristics, often designed today as hybrid quantum-
classical algorithms, such as the class of Variational Quantum Algorithms described by Cerezo
et al. (2021) or by Grange et al. (2023b) and, within it, the famous Quantum Approximate
Optimization Algorithm (QAOA) of Farhi et al. (2014). Essentially, these algorithms require
the optimization problem to be formulated as an unconstrained binary problem with polynomial
objective function and can be implemented on current noisy quantum computers because the
quantum part can be made rather small. Note that, usually, the problem is formulated as a
QUBO (Quadratic Unconstrained Binary Optimization) to limit the number of entanglement
gates. Among others, the problems of MAX-CUT (Farhi et al., 2014), Travelling Salesman
Problem (Ruan et al., 2020), MAX-3-SAT (Nannicini, 2019), Graph Coloring (Tabi et al.,
2020) and Job Shop Scheduling (Kurowski et al., 2023) are reformulated as QUBO and solved
with hybrid heuristics on small instances. However, due to the small size of instances processed
today and the nature of heuristics whose performances are evaluated empirically, no quantum
advantage with these heuristics is emerging yet. This is where the second type of quantum
algorithms differ: they are exact algorithms (i.e. that output the optimal solution with a high
probability of success) that provide theoretical speed-ups for several types of problems and
algorithms, as displayed by Nannicini (2022) and Sutter et al. (2020). Notice that with the
current quantum hardware, it is impossible to implement them today because of the huge size
of quantum resources they require.
Grover (1996) provides one key exact quantum algorithm, that achieves a quadratic speed-up
when searching for a specific element in an unsorted table, where the complexity is computed as
the number of queries of the table and is done by an oracle. Grover Search represents the routine
of many exact quantum algorithms. For instance, Dürr and Høyer (1996) use Grover Search as
a subroutine for a hybrid quantum-classical algorithm that finds the minimum of an unsorted
table, resulting in the algorithm called Quantum Minimum Finding. Later, Ambainis et al.
(2019) combine Quantum Minimum Finding with dynamic programming to address NP-hard
vertex ordering problems, such as the Traveling Salesman Problem (TSP) or the Minimum
Set Cover problem. The problems of interest must satisfy a specific property which implies
that they can be solved by classical dynamic programming in O∗ (cn ), where c is usually not
smaller than 2. Henceforth, we use O∗ which is the usual asymptotic notation that ignores the
polynomial factors in the complexity. The hybrid algorithm of Ambainis et al. (2019) reduces
the complexity to O∗ (cnquant ) for cquant < c. As an example, Held and Karp (1970) dynamic

2
programming solves the TSP in O∗ (2n ) whereas the hybrid algorithm of Ambainis et al. (2019)
achieves to solve it in O∗ (1.728n ) by combining the dynamic programming recurrence of Held
and Karp with Quantum Minimum Finding. Following the work of Ambainis et al. (2019), other
NP-hard problems have been tackled with the idea of combining Grover Search (or Quantum
Minimum Finding) and classical dynamic programming. This has led to quantum speed-ups
for the Steiner Tree problem (Miyamoto et al., 2020) and the graph coloring problem (Shimizu
and Mori, 2022).
The purpose of this work is to provide a hybrid quantum-classical algorithm, adapting the
seminal idea of Ambainis et al. (2019), that reduces the time complexity of solving NP-hard
scheduling problems. For that, we propose an extended version of well-known Dynamic Pro-
gramming Across the Subsets (DPAS) recurrences used to solve combinatorial optimization
problems like scheduling problems (see e.g. T’kindt et al. (2022)). Notice that DPAS is a com-
mon technique for designing exact algorithms for NP-hard problems as described by Woeginger
(2003).

Scheduling problems and DPAS. A scheduling problem lies in finding the optimal assign-
ment of a set of jobs to machines over time. Each job j is defined by at least a processing time
pj and possibly additional data like a due date dj , a deadline d˜j , or even a weight wj reflecting
its priority. One or more machines can process the set of jobs, however, at any time point, a
machine can only process one job at a time. The computation of a schedule is done to minimize
a given objective function.
In Sections 2 and 3, we consider single-machine scheduling problems. Let [n] := {1, . . . , n}
be the set of jobs to schedule on the machine. While a solution to a single-machine scheduling
problem is described by a starting time for each job on the machine, it is standard to describe
instead such a solution by a permutation π ∈ S[n] of the n jobs. Indeed, the starting times can be
directly deduced from the order of jobs in the permutation and the potential constraints thanks
to the following assumptions. First, we assume that only one job can be processed at any time
on the machine. Second, we deal only with non-preemptive scheduling, meaning that a job must
be run to completion when it started. Henceforth, we use the permutation representation for
the solutions. In Section 5, we consider the 3-machine flowshop of n jobs. The definition of this
problem, introduced in the above-mentioned section, makes also a solution entirely described
by a permutation of [n] even if there are 3 machines.
Throughout this paper, we use the usual notation α|β|γ, introduced by Graham et al. (1979),
to describe the scheduling problem consisting of α machines, with the constraints β and the
criterion γ to be minimized. For instance, 1|d˜j | j wj Cj is the problem of minimizing the total
P

3
weighted completion time with deadline constraints on a single machine. The reader interested
in scheduling can refer to any textbook in scheduling, e.g. to Pinedo (2012).
The single-machine scheduling problems addressed in this work are those that satisfy the
Dynamic Programming Across the Subsets (DPAS) property. It means that these problems
can be solved by Dynamic Programming where the optimal solution for a set of jobs J ⊆ [n] is
computed as the best concatenation over all j ∈ J of the optimal solution for J \ {j} and the
cost of setting j as the last processed jobs. Specifically, if we note OPT[J] the optimal value
for processing the set J of jobs, the recursion is
!
X
OPT[J] = min OPT[J \ {j}] + ϕj pk , (1)
j∈J
k∈J

where ϕj is a function depending on job j. This generic recursion captures many single-machine
scheduling problems as recalled in the survey of T’kindt et al. (2022), leading to the worst-case
time complexity of O∗ (2n ) to solve all these problems. This naturally raises the question of
the existence of moderate exponential-time algorithms with a complexity O∗ (cn ) where c < 2.
The question has been answered positively for specific problems such as minimizing the total
weighted completion time with precedence constraints in O∗ ((2 − ϵ)n ) for small ϵ > 0 by Cygan
et al. (2014). But, as far as we know, no generic method provides such an improvement for a
broad class of scheduling problems. In this paper, we present a hybrid algorithm that solves the
problems satisfying (1) in O∗ (1.728n ), sometimes with an additional pseudo-polynomial factor
in the complexity that comes from the generalization of the recurrence.

Our contributions. We extend existing recurrences for scheduling problems leading to a

quantum speed-up for solving a general class of scheduling problems. The dynamic programming
recurrences are adapted to solve scheduling problems with a proposed hybrid algorithm Q-
DDPAS, which is an extension of the algorithm of Ambainis et al. (2019). Specifically, Q-DDPAS
relies on dynamic programming over values indexed by a set, as by Ambainis et al. (2019), but
also indexed by a new integer parameter. This new indexation is of a different nature from
indexing with a set because it is not exhaustively enumerated in the recurrence but enables
to express temporal constraints. Q-DDPAS also deals with non-linear objective functions, for
which it is not sufficient anymore to add values of subsets. These require instead new ways to
combine values, e.g. composition, coming from the specificity of scheduling objective functions.
Specifically, we cover three types of problems that satisfy three different kinds of dynamic
programming properties. For each of them, the best-known classical time complexity is in
O∗ (2n ) that is reduced in O∗ (pseudop · 1.728n ) by the hybrid algorithm of this paper, where
pseudop is a pseudo-polynomial factor. Not only it applies to problems for which the dynamic

4
programming property is based on the addition of optimal values of the problem on sub-instances
(as done by Grange et al. (2023a)) but it also relates to problems for which the dynamic
programming naturally applies on the composition of optimal values of the problem on sub-
instances. Furthermore, we address the 3-machine flowshop problem that differs from previous
problems by the nature of the recurrence property. Last, we also propose an approximation
scheme for the 3-machine flowshop problem based on the hybrid algorithm. We summarize in
Table 1 the complexities of several NP-hard scheduling problems through which we illustrate
the recurrences in this paper.

Problem Our hybrid algorithm Best classical algorithm

1|d˜j | O∗ ( pj · 1.728n ) O∗ (2n ) (T’kindt et al., 2022)

P P
wj Cj

O∗ ( pj · 1.728n ) O∗ (2n ) (T’kindt et al., 2022)

P P
1|| wj Tj

O∗ (1.728n ) O∗ ((2 − ϵ)n ), for small ϵ (Cygan et al., 2014)

P
1|prec| wj Cj

O∗ ( wj )3 · pj · 1.728n O∗ ( wj · pj · 2n ) (Ploton and T’kindt, 2022)

P P P
P P
1|rj | wj Uj

O∗ ( wj )3 · ( pj )4 · 1.728n O∗ ( wj · ( pj )2 · 2n ) (Ploton and T’kindt, 2022)

P P P
P P
1|rj | wj Cj

O∗ ( pij )4 · 1.728n O∗ (3n ) (Shang et al., 2018; Ploton and T’kindt, 2023)
P

F 3||Cmax

Table 1: Comparison of worst-case time complexities between our hybrid algorithm and the
best-known classical algorithm.

Structure of the paper. First, we present in Section 2 problems for which the dynamic pro-
gramming property is based on the addition of optimal values of the problem on sub-instances
(called Additive DPAS). We begin with the example of problem 1|d˜j | j wj Cj and then provide
P

a generic description of the problems at stake. We describe the related hybrid algorithm (called
Q-DDPAS) as it is usually done in the algorithmic quantum literature, namely with a high-level
description where quantum boxes interact with the classical part. We provide a rigorous and
detailed description of the circuit-based implementation for interested readers in our companion
paper (Grange et al., 2024). Similarly, we tackle in Section 3 problems for which the dynamic
programming property is based on the composition of optimal values of the problem on sub-
P
instances (called Composed DPAS), beginning with the example of problem 1|rj | wj Uj . We
provide in Section 4 some applications of Q-DDPAS to the scheduling literature. Lastly, in
Section 5, we consider the 3-machine flowshop problem, for which the dynamic programming
recurrence applies to its decision version. It results in a slightly different hybrid algorithm.
Additionally, we provide an approximation scheme for this problem, based on the hybrid al-

5
gorithm, that disposes of the pseudo-polynomial factor in the time complexity. We recall in
Appendix A useful bounds to derive the complexities of the proposed algorithms.

2 Additive DPAS

In this section, we present problems for which the dynamic programming recursion is based
on the addition of optimal values of problems for sub-instances. Next, we detail the hybrid
algorithm Q-DDPAS to solve these problems.

2.1 A scheduling example

The NP-hard single-machine scheduling problem at stake is the minimization of the total
weighted completion time with deadline constraints, often referred to as 1|d˜j | j wj Cj in the
P

scheduling literature. The input is given, for each job j ∈ [n], by a weight wj , a processing time
pj and a deadline d˜j before which the job must be completed. We define the completion time
Cj (π) of job j as the end time of the job on the machine for the permutation π. So, if j starts
as time t for the permutation π, then Cj (π) = t + pj . The problem aims at finding the feasible
permutation for which the total weighted sum of completion times is minimal. A permutation
π is feasible if Cj (π) ≤ d˜j for all job j. Thus, the problem can be formulated as follows:
n
X
min wj Cj (π) ,
π∈Π
j=1

where the set of feasible permutations is Π = {π ∈ S[n] | Cj (π) ≤ d˜j , ∀j ∈ [n]} .

This problem satisfies two recurrences. For deriving them, we need to introduce the set
T := {0, 1, . . . , nj=1 pj }. For J ⊆ [n] and t ∈ T , we define OPT[J, t] as the optimal value of the
P

problem in which only jobs in J are scheduled from time t. Thus, solving our nominal problem
1|d˜j | j wj Cj amounts to compute OPT[[n], 0].
P

The first recurrence comes from the standard Dynamic Programming Across the Subsets
(DPAS) described in (1). However, compared to usual DPAS, we introduce an extra parameter
t necessary for the solution with our hybrid algorithm as explained later. The idea of this
recurrence is to get the optimal value of our problem for jobs in J and starting at time t
by finding, over all jobs j ∈ J, the permutation that ends by j with the best cost value. It
is possible to do so because no matter what the optimal permutation of the first (|J| − 1)
jobs is, the cost of setting job j at the end of the permutation is always known. Indeed, the
P
time taken to process all jobs in J \ {j} is always k∈J\{j} pk . Thus, the completion time
P
of j is defined by cj = t + k∈J pk . It results that the cost of setting j at the end of the

6
 P
permutation is wj (t + k∈J pk ). It also implies that the deadline constraint for job j is satisfied
if t + k∈J pk ≤ d˜j . Specifically, for all J ⊆ [n] and for all t ∈ T , we have
P
 !
X X
pk ≤ d˜j

wj t + pk if t +


OPT[J, t] = min OPT[J \ {j}, t] + k∈J k∈J , (2)
j∈J 

+∞

otherwise

initialized by OPT[∅] = 0.
The second recurrence generalizes the previous one. For this recurrence, the principle of
computing OPT[J, t] is similar to (2) but instead of setting one job at the end of the permutation,
we choose |J|/2 jobs and set them to be the half last jobs of the permutation. Specifically, for
all J ⊆ [n] of even cardinality and t ∈ T , we have
n X o
OPT[J, t] = min OPT[X, t] + OPT[J \ X, t + pi ] , (3)
X⊆J
|X|=|J|/2 i∈X

wj (pj + t) if d˜j ≥ pj + t

initialized by, ∀j ∈ [n] and t ∈ T , OPT[{j}, t] = .
+∞

otherwise
For a given X ⊆ J of size |J|/2, recurrence (3) computes the best permutation of jobs in X
P
starting at time t, and the best permutation of jobs in J \ X starting at time t + k∈X pk as we
know that, as before, no matter what is the optimal permutation for jobs in X, the time taken
P
to process them all is exactly k∈X pk .
The two above recurrences have been illustrated with problem 1|d˜j | j wj Cj . In the next
P

subsection, we propose a general formulation of these recurrences that will be used to elaborate
our algorithm as general as possible to solve a broad class of scheduling problems.

2.2 General formulation of recurrences

Let us consider the following general scheduling problem:

P: min f (π) ,
π∈Π

where Π ⊆ S[n] is the set of feasible permutations of [n] := {1, . . . , n} according to given
constraints and f is the objective function. We introduce a related problem P useful for deriving
the dynamic programming recursion, for which we specify the instance: for J ⊆ [n] and t ∈ Z,

P (J, t) : min f (π, J, t) (4)

π∈Π(J,t)

as the nominal scheduling problem P that schedules only jobs in J and starts the schedule at
time t. Let us note OPT[J, t] the optimal value of P (J, t). It results that solving P amounts to
solving P ([n], 0), and it can be performed by Q-DDPAS if the related problem P satisfies the

7
two recurrences (Add-DPAS) and (Add-D-DPAS) below. Henceforth, we denote by 2[n] the set
of all subsets of [n], and by Ja, bK the set {a, a + 1, . . . , b}. Let us introduce the first recurrence.

Property 2.1 (Additive DPAS). There exists a function g : 2[n] × [n] × T → R, computable in
polynomial time, such that, for all J ⊆ [n] and for all t0 ∈ T ,
n o
OPT[J, t0 ] = min OPT[J \ {j}, t0 ] + g(J, j, t0 ) (Add-DPAS)
j∈J

initialized by OPT[∅, t0 ] = 0.

Lemma 2.2. Dynamic programming (Add-DPAS) solves P in O∗ (2n ).

Proof. We solve Equation (Add-DPAS) for all J such that |J| = k, and for t0 = 0, starting
from k = 1 to k = n. For a given J, the values {OPT[J \ {j}, 0] : j ∈ J} are known, so
OPT[J, 0] is computed in time poly(n) · k according to Equation (Add-DPAS), where poly(n) is
a polymial function of n (the computation of g is polynomial). Eventually, the total complexity
of computing OPT[[n], 0] is nk=1 poly(n)k nk = poly(n) · n · 2n−1 = O∗ (2n ).
P

Throughout, we commit a slight abuse of language by letting (Add-DPAS) both refer to the
property satisfied by a given optimization problem and to the resulting dynamic programming
algorithm. Notice the presence of the additional parameter t0 in the above definition, which
is typically absent in the scheduling literature. In particular, t0 is a constant throughout the
whole recursion (Add-DPAS) and does not impact the resulting computational complexity. The
use of that extra parameter in T shall be necessary later when applying our hybrid algorithm.
Property 2.1 expresses that finding the optimal value of P for jobs in J and starting at time
t is done by finding over all jobs j ∈ J the permutation that ends by j with the best cost value.
Function g represents the cost of j being the last job of the permutation. Notice that isolating
the last job of the permutation is a usual technique in scheduling as displayed in (1). In the
second recurrence below, we provide a similar scheme, where instead of one job, we isolate
half of the jobs in J, turning the computation of g to the solution of another problem on a
sub-instance with |J|/2 jobs.

Property 2.3 (Additive Dichotomic DPAS). There exist two functions τshift : 2[n] ×2[n] ×T → T
and h : 2[n] × 2[n] × T → R, computable in polynomial time, such that, for all J ⊆ [n] of even
cardinality, and for all t ∈ T ,
n o
OPT[J, t] = min OPT[X, t] + h(J, X, t) + OPT[J \ X, τshift (J, X, t)] (Add-D-DPAS)
X⊆J
|X|=|J|/2

initialized by the values OPT[{j}, t] for each j ∈ [n] and t ∈ T .

8
 For a given X ⊆ J, the above recursion computes the best permutation of jobs in X starting
at time t, and the best permutation of jobs in J \ X starting at time τshift , adding the function
h that represents the cost of the concatenation between these two permutations.

Remark 2.4. We observe that problem (4) satisfies recurrence (Add-DPAS) if and only if it
satisfies (Add-D-DPAS). This can be seen by developing recursively both recurrences, which
essentially leads to optimization problems over π ∈ S[n] , whose objective functions respectively
involve g in the first case and h and τshift in the second case. Here, one readily verifies that g
can then be defined from h and τshift and reciprocally.

Despite the previous remark, the two recurrences differ on the size of the subsets considered
along the recursions, leading to different formulations and therefore require more or less sub-
problems to be solved optimally in the dynamic programming process. This is formalized in
the following proposition. Note that we use the notation f1 (n) = ω(f2 (n)) if f1 dominates
asymptotically f2 .

Lemma 2.5. Dynamic programming (Add-D-DPAS) solves P in ω(|T | · 2n ).

The proof is given in the Supplementary Materials. Notice that if n is not a power
of 2, we can still add fake jobs without changing the following conclusion: solving P
with (Add-DPAS) is faster than with (Add-D-DPAS). However, in the next subsection, we
describe a hybrid algorithm Q-DDPAS that improves the complexity of solving P by combining
recurrences (Add-DPAS) and (Add-D-DPAS) with a quantum subroutine.

2.3 Hybrid algorithm for Additive DPAS

In this subsection, we describe our hybrid algorithm Q-DDPAS adapted from the work
of Ambainis et al. (2019). Notice that it assumes to have a quantum random access memory
(QRAM) (Giovannetti et al., 2008), namely, to have a classical data structure that stores
classical information but can answer queries in quantum superposition. We underline that this
latter assumption is strong because QRAM is not yet available on current universal quantum
hardware. First, let us introduce the Quantum Minimum Finding algorithm of Dürr and
Høyer (1996), which constitutes a fundamental subroutine in our algorithm. This algorithm
essentially applies several times Grover Search (Grover, 1996) and provides a quadratic speedup
for the search of a minimum element in an unsorted table.

Definition 2.6 (Quantum Minimum Finding (Dürr and Høyer, 1996)). Let f : [n] → Z be a
function. Quantum Minimum Finding computes the minimum value of f and the corresponding

9
 √
minimizer arg mini∈[n] {f (i)}. The complexity of Quantum Minimum Finding is O ( n · Cf (n)),
where O(Cf (n)) is the complexity of computing a value of f .

Remark 2.7 (Success probability and bounded-error algorithm (Bernstein and Vazirani, 1993)).
Dürr and Høyer (1996) prove that Quantum Minimum Finding computes the minimum value
1
with a probability of success strictly larger than 2, independent of n. Thus, for ϵ > 0, finding
the minimum value with probability (1 − ϵ) is achieved by repeating O(log 1ϵ ) times Quantum
Minimum Finding. Henceforth, we refer to this statement when we write that Quantum Mini-
mum Finding finds the minimum value with high probability. Equivalently, we say that this is
a bounded-error algorithm. More generally, in the rest of the paper, we call a bounded-error
algorithm an algorithm that provides the optimal solution with a probability as close to 1 as we
want by repeating it a number of times independent of the instance size.

Next, we describe the algorithm of Ambainis et al. (2019) adapted for our Additive DPAS
recurrences which implies extra parameters in T . We call it Q-DDPAS and it consists essentially
of calling recursively twice Quantum Minimum Finding and computing classically the left terms.
Without loss of generality, we assume that 4 divides n. This can be achieved by adding at
most three fake jobs and, therefore, does not change the algorithm complexity. Q-DDPAS
consists of two steps. First, we compute classically by (Add-DPAS) the optimal values of P
on sub-instances of n/4 jobs and for all starting times t ∈ T . Second, we call recursively
two times Quantum Minimum Finding with (Add-D-DPAS) to find optimal values of P on
sub-instances of n/2 jobs starting at any time t ∈ T , and eventually of n jobs starting at
t = 0 (corresponding to the optimal value of the nominal problem P). Specifically, we describe
Q-DDPAS in Algorithm 1.

Theorem 2.8. The bounded-error algorithm Q-DDPAS (Algorithm 1) solves P in O∗ (|T | ·

1.754n ).

The detailed proof of the correctness of the algorithm, involving the description of the gate
implementation, is detailed in the companion paper (Grange et al., 2024), with all the low-level
details for implementing the algorithm.

Proof. Hereafter, we provide a high-level proof. The upper bounds to simplify the complexities
are detailed in the Appendix A.

• Classical part: computing all OPT[X, t] for all X of size n/4 and for all t ∈ T (Step 1 in
 Pn/4

Algorithm 1) is done by (Add-D-DPAS) in time O∗ |T | · k=1 k nk = O∗ (|T | · 20.811n ).

10
 Algorithm 1: Q-DDPAS for Additive DPAS
Input: Problem P satisfying Additive DPAS recurrences
Output: OPT[[n], 0] with high probability
begin classical part
for X ⊆ [n] such that |X| = n/4, and t ∈ T do
1 Compute OPT[X, t] with (Add-DPAS) and store the results in the QRAM;

begin quantum part

2 Apply Quantum Minimum Finding with (Add-D-DPAS) to find OPT[[n], 0];
3 To get values for the Quantum Minimum Finding above (the values OPT[J, t] for
J ⊆ [n] of size n/2 and t ∈ T ), apply Quantum Minimum Finding
with (Add-D-DPAS);
4 To get values for the Quantum Minimum Finding above (the values OPT[X, t′ ] for
X ⊆ [n] of size n/4 and t′ ∈ T ), get them on the QRAM

• Quantum part: according to Quantum Minimum Finding complexity (Definition 2.6),

computing OPT[[n], 0] with Quantum Minimum Finding (Step 2 in Algorithm 1) is done
q 
n


in O n/2 · C 1 (n) , where C1 (n) is the complexity of computing OPT[J, t] for a J of
size n/2 and t ∈ T . The essence of the quantum advantage here is that we do not need to
enumerate all sets J and all time t but we apply the Quantum Minimum Finding in parallel
n


to all at once. Notice that n/2 is the number of balanced bi-partitions of [n], namely the
number of elements we search over to find the minimum of Equation (Add-D-DPAS) when
computing OPT[[n], 0]. Thus, C1 (n) is exactly the complexity of Quantum Minimum
q 
n/2

Finding applied on Step 3 in Algorithm 1, namely C1 (n) = O n/4
· C 2 (n) where
C2 (n) is the complexity of computing OPT[X, t′ ] for X of size n/4 and t′ ∈ T . Those
values are already computed and stored in the QRAM (Step 1 in Algorithm 1), namely,
q
n/2

n
C2 (n) = O∗ (1). Thus, the quantum part complexity is O∗ n/2 n/4 = O∗ (20.75n ).

Eventually, Q-DDPAS complexity is the maximum of the classical and the quantum part com-
plexity. Specifically, the total complexity is O∗ (|T | · 20.811n ) = O∗ (|T | · 1.754n ).

We observe that the complexity of Q-DDPAS can be further reduced by performing a third
call to Equation (Add-D-DPAS) as suggested by Ambainis et al. (2019).

Observation 2.9. A slight modification of Q-DDPAS reduces the complexity to O∗ (|T |·1.728n ).

Proof. The slight modification of Q-DDPAS amounts to adding a level of recurrence in the
quantum part so that the complexity of the classical part reduces whereas the complexity of the

11
quantum part increases so that both are equal and thus minimize the total complexity. The third
call searches for the best concatenation among all the bi-partitions of size (0.945 · n4 , 0.055 · n4 )
(that are integers asymptotically), i.e. solving
n o
OPT[J, t] = min OPT[X, t] + h(J, X, t) + OPT[J \ X, τshift (J, X, t)] .
X⊆J
|X|=0.945|J|

The classical part computes all OPT[X, t] for X of size 0.945 · n

4 and 0.055 · n4 , in O∗ (1.728n ) .
The quantum part applies three levels of recurrence of Quantum Minimum Finding, computing
n

n/2
n/4

the minimum over functions with a domain of size n/2 , n/4 and 0.945·n/4 respectively. Its
q 
n n/2 n/4
complexity is then O∗ = O∗ (1.728n ) (see Appendix A).




n/2 n/4 0.945·n/4

Notice that the classical part of Q-DDPAS can be replaced by any classical algorithm A, if
A computes in O∗ (|T | · 1.728n ) all OPT[X, t] for X ⊆ [n] of size n/4 and t ∈ T . Moreover, if
A happens to reduce the classical part complexity O∗ (|T | · cn ) for c < 1.728, the complexity of
Q-DDPAS can also be reduced in the same spirit as the slight modification of Observation 2.9.
The application of Q-DDPAS for Additive DPAS to the specific problem 1|d˜j | j wj Cj in-
P

troduced in Subsection 2.1 is given in Subsection 4.1, together with other scheduling examples.
Before introducing other types of problems tackled by Q-DDPAS in the next section, we provide
some insights to underline why the use of the quantum subroutine Quantum Minimum Find-
ing in Q-DDPAS must be carefully combined with classical computation to achieve a quantum
speedup.

Remark 2.10. Solving P with (Add-DPAS) and replacing each classical computation of the
minimum by the quantum subroutine Quantum Minimum Finding would not improve the best
√

classical complexity. Indeed, the complexity would be nk=1 poly(n) k nk = O∗ (2n ) .
P

Remark 2.11. Solving P exclusively by recursive calls to Quantum Minimum Finding (thus
avoiding the classical computations for sets of size n/4) would not improve the classical complex-
ity. Using recurrence (Add-D-DPAS), which is the quantum part of Algorithm 1 with roughly
q
n/2


n 2
log2 (n) recursive calls, would give a complexity in O n/2 n/4 . . . 1 that is worse than
O∗ (2n ). Using recurrence (Add-DPAS) would be even worse because it would require n recursive
p
calls leading to the complexity O( n(n − 1) . . . 1).

3 Composed DPAS

In this section, we study scheduling problems whose constraints enable only the composition of
problems on sub-instances. We describe the adaptation of Q-DDPAS for these problems.

12
3.1 A scheduling example

We begin with the specific problem of minimizing the total weighted number of late jobs with
P
release date constraints, often referred to as 1|rj | wj Uj in the literature. The input is given
by, for each job j ∈ [n], a weight wj , a processing time pj , a release date rj that is the time
from which the job can be scheduled (and not before), and a due date dj that indicates the
time after which the job is late. Thus, a job j is late in permutation π if its completion time
is larger than dj , namely if Cj (π) > dj . We name Uj (π) = 1Cj (π)>dj its indicator function of
lateness. This problem aims at finding the feasible permutation, namely where each job starts
after its release date, for which the total weighted number of late jobs is minimal. Thus, the
problem can be formulated as follows:
n
X
min wj Uj (π) ,
π∈Π
j=1

where the set of feasible solutions is Π = {π ∈ S[n] | Cj (π) ≥ rj + pj } .

This problem does not satisfy the recurrences (Add-DPAS), and thus (Add-D-DPAS), because
the release date constraints do not allow the addition of sub-instances. Let us take the example
of (Add-D-DPAS). The starting time of the second half of jobs J \ X in (Add-D-DPAS) can
be known only if we know the optimal permutation of the first half job, which is in opposition
with the dynamic programming principle. Indeed, the release dates enable empty slots in the
scheduling on the first half job such that the time to process all these jobs is not always equal
P
to k∈X pk and can be larger.
This observation leads to different recurrences, where the time to process the jobs would
be known by dynamic programming. For that, we define an auxiliary problem on which the
r P z
recurrences apply and we introduce a new set of parameters E := 0, nj=1 wj . For J ⊆ [n],
r P z
t ∈ T := 0, nj=1 pj ∪ {+∞} and ϵ ∈ E, we note OPT[J, t, ϵ] the minimum makespan, i.e. the
completion time of the last job, for jobs in J beginning at time t where the weighted number
of late jobs is exactly ϵ. Notice that by convention, OPT[J, t, ϵ] = +∞ if there is no feasible
n P o
solution, i.e. if π ∈ SJ : Cj (π) ≥ max(t, rj ) + pj , ∀j ∈ J and w U
j∈J j j (π) = ϵ = ∅. Thus,
P
our initial problem 1|rj | wj Uj is

min{ϵ : OPT[[n], 0, ϵ] < +∞} .

ϵ∈E

The following recurrence that satisfies the auxiliary problem is inspired by the work of Lawler
(1990) for the problem of minimizing the total weighted number of late jobs on a single machine

13
 P
under preemption and release date constraints (1|rj , pmtn| wj Uj ). For J ⊆ [n], t ∈ T , ϵ ∈ E,
n h i h io
OPT[J, t, ϵ] = min OPT {j}, OPT[J \ {j}, t, ϵ], 0 , OPT {j}, OPT[J \ {j}, t, ϵ − wj ], wj .
j∈J
| {z } | {z }
job j is not late job j is late

In this recurrence, for each j ∈ J, we impose j as the last job of the permutation and distinguish
two cases, whether it is late or not. Notice that the starting time of j is known and equal to
OPT[J \{j}, t, .] which represents the value for the time parameter. The recurrence is initialized
by, for j ∈ [n], t ∈ T and ϵ ∈ E,

Cj := max(t, rj ) + pj , if Cj ≤ dj and ϵ = 0








+∞, if Cj > dj and ϵ = 0 , or if Cj ≤ dj and ϵ = wj


OPT[{j}, t, ϵ] =


 Cj , if Cj > dj and ϵ = wj

 n

 X
+∞, if ϵ ∈ J1, wj − 1K ∪ Jwj + 1, wk K



k=1

This recurrence generalizes into the following dichotomic version for which, instead of setting
the last job of the permutation, we set the half-last jobs. For all J ⊆ [n] of even cardinality,
t ∈ T and ϵ ∈ E,
n h io
OPT[J, t, ϵ] = min
′
OPT X, OPT[J \ X, t, ϵ − ϵ′ ], ϵ′ ,
ϵ ∈E
X∈J:|X|=|J|/2

initialized by the same values of OPT[{j}, t, ϵ] for j ∈ [n], t ∈ T and ϵ ∈ E. Next, we provide
generic recurrences to consider problems for which the composition of sub-instances is possible.

3.2 General formulation of recurrence

Let us consider a scheduling problem with n jobs

P: min f (π) ,
π∈Π

where Π ⊆ S[n] is the set of feasible permutations of [n] := {1, . . . , n} according to given
constraints and f is the objective function. Following the example detailed in the previous
subsection, we consider an auxiliary problem P ′ useful for deriving the dynamic programming
recursion, for which we specify the instance: for J ⊆ [n] the jobs to be scheduled, t ∈ Z the
starting time of the schedule and ϵ ∈ Z, we define

P ′ (J, t, ϵ) : min f ′ (π, J, t, ϵ) , (5)

π∈Π′ (J,t,ϵ)

where f ′ , respectively Π′ , is the objective function, respectively the feasible set, are different
from those of P. We assume that solving P amounts to finding the smallest ϵ ∈ Z such that

14
the auxiliary problem P ′ is bounded. Specifically,
n o
P: min ϵ : OPT[[n], 0, ϵ] < +∞ . (6)
ϵ∈Z

To solve the nominal problem P by classical dynamic programming, problem P ′ must satisfy
recurrence (Comp-DPAS) or recurrence (Comp-D-DPAS) below (as in Remark 2.4, we can state
that a problem satisfies one if and only if it satisfies the other one). As we explain later, solving
P with our hybrid algorithm requires problem P ′ to satisfy one of the two recurrences below.

Property 3.1 (Composed DPAS). For all J ⊆ [n], t ∈ T and ϵ ∈ E,

n h io
′ ′
OPT[J, t, ϵ] = min
′
OPT {j}, OPT[J \ {j}, t, ϵ − ϵ ], ϵ , (Comp-DPAS)
ϵ ∈E
j∈J

initialized by the values of OPT[{j}, t, ϵ] for all j ∈ [n], ϵ ∈ E and t ∈ T . Notice that for
J ⊆ [n], t ∈ T and ϵ ∈ E, we adopt the convention OPT[J, t, ϵ] = +∞ for ϵ ∈
/ E.

Recurrence (Comp-DPAS) differs from recurrence (Add-DPAS) in two aspects. First, the
optimal values of the problem on sub-instances are composed, and not added, because of the
nature of the constraints. Second, the search for the minimum value is done not only over all
jobs in J, but also over all values in E. More precisely, for a given ϵ0 ∈ E, the optimal value of
P ′ (J, t, ϵ0 ) is the minimum value of all possible composition of optimal values of the problem on
sub-instances with parameters ϵ1 and ϵ2 such that ϵ1 + ϵ2 = ϵ0 . We have the following result.

Lemma 3.2. (Comp-DPAS) solves P in O∗ (|E|3 · |T | · 2n ).

Proof. Let ϵ0 ∈ E. Similarly to the proof of Lemma 2.2, we show that (Comp-DPAS) solves
P ′ ([n], 0, ϵ0 ) in O∗ (|E|2 · |T | · 2n ). Indeed, to compute OPT[[n], 0, ϵ0 ], we need to solve Equa-
tion (Comp-DPAS) for all J such that |J| = k starting from k = 1 to k = n, and for all t ∈ T
and ϵ ∈ E. For a given J, t ∈ T and ϵ ∈ E, the values {OPT[J \ {j}, t′ , ϵ′ ] : j ∈ J, t′ ∈ T, ϵ′ ∈ E}
and {OPT[{j}, t′ , ϵ′ ] : j ∈ J, t′ ∈ T, ϵ′ ∈ E} are known, so OPT[J, t, ϵ] is computed in time
|E| · k according to Equation (Comp-DPAS). Eventually, the total complexity of computing
OPT[[n], 0, ϵ0 ] is nk=1 |T | · |E|2 · k nk = O∗ (|T | · |E|2 · 2n ). Moreover, solving P amounts to
P

solving P ′ ([n], 0, ϵ) ,for all ϵ ∈ E, according to (6). The complexity results directly from the
above complexity of computing OPT[[n], 0, ϵ0 ], for ϵ0 ∈ E.

The dichotomic version of the previous recurrence is the following.

Property 3.3 (Composed Dichotomic DPAS). For all J ⊆ [n] of even cardinality, t ∈ T, ϵ ∈ E,
n h io
OPT[J, t, ϵ] = min
′
OPT X, OPT[J \ X, t, ϵ − ϵ′ ], ϵ′ , (Comp-D-DPAS)
ϵ ∈E
X∈J:|X|=|J|/2

15
initialized by the values of OPT[{j}, t, ϵ] for all j ∈ [n], t ∈ T and ϵ ∈ E.

Lemma 3.4. (Comp-D-DPAS) solves P in ω(|E|3 · |T | · 2n ).

Proof. This proof is essentially the same as the one of Lemma 2.5 with the same modifications
that for the proof of Lemma 3.2.

As for the Additive DPAS, we notice that, with a classical dynamic programming algo-
rithm, the time complexity to solve P with recurrence (Comp-DPAS) is better than with recur-
rence (Comp-D-DPAS). Next, we show that the hybrid algorithm applied to problems satisfying
Additive DPAS recurrences can be easily adapted to tackle problems satisfying Composed DPAS
recurrences.

3.3 Hybrid algorithm for Composed DPAS

The hybrid algorithm for Composed DPAS derives naturally from Algorithm 1. It amounts
to replacing the recurrence (Add-DPAS), respectivelly (Add-D-DPAS), by (Comp-DPAS), re-
spectivelly (Comp-D-DPAS), resulting in Algorithm 2. Eventually, we use Algorithm 2 as a
subroutine to solve Equation (6), i.e. to solve the nominal problem P.

Algorithm 2: Q-DDPAS for Composed DPAS

Input: ϵ0 ∈ E, auxiliary problem P ′ satisfying Composed DPAS recurrences
Output: OPT[[n], 0, ϵ0 ] with high probability
begin classical part
for X ⊆ [n] such that |X| = n/4, and t ∈ T do
Compute OPT[X, t, ϵ0 ] with (Comp-DPAS) and store the results in the QRAM;

begin quantum part

Apply Quantum Minimum Finding with (Comp-D-DPAS) to find OPT[[n], 0, ϵ0 ];
To get values for the Quantum Minimum Finding above (the values OPT[J, t, ϵ] for
J ⊆ [n] of size n/2, t ∈ T and ϵ ∈ E), apply Quantum Minimum Finding
with (Comp-D-DPAS);
To get values for the Quantum Minimum Finding above (the values OPT[X, t′ , ϵ′ ]
for X ⊆ [n] of size n/4, t′ ∈ T and ϵ′ ∈ E), get them on the QRAM

Lemma 3.5. Let ϵ0 ∈ E. The bounded-error algorithm Q-DDPAS (Algorithm 2) solves

P ′ ([n], 0, ϵ0 ) in O∗ (|E|2 · |T | · 1.754n ).

16
 Notice that the implementation of this algorithm is slightly different from the one of Algo-
rithm 1, mainly due to the operation of composition. The details are given in the companion
paper (Grange et al., 2024).

Algorithm 3: Meta-algorithm with subroutine Q-DDPAS for Composed DPAS

Input: Auxiliary problem P ′ satisfying Composed DPAS recurrences
n o
Output: min ϵ : OPT[[n], 0, ϵ] < +∞ with high probability
ϵ∈E

ϵ∗ ← +∞;
for ϵ ∈ E do
Solve P ([n], 0, ϵ) with Algorithm 2;
if OPT[[n], 0, ϵ] < +∞ and ϵ < ϵ∗ then
ϵ∗ ← ϵ;

Return ϵ∗

Theorem 3.6. The bounded-error Algorithm 3, with Q-DDPAS as a subroutine, solves P in

O∗ (|E|3 · |T | · 1.754n ).

As for the case of Q-DDPAS for Additive DPAS, we can reduce the exponential part of Q-
DDPAS complexity for Composed DPAS, by the modification indicated in Observation 2.9, thus
leading to the following observation.

Observation 3.7. A slight modification of the Q-DDPAS algorithm can reduce the complexity
of Algorithm 3 to O∗ (|E|3 · |T | · 1.728n ).

We illustrate in Subsection 4.2 the application of Q-DDPAS for Composed DPAS to the
P
problem 1|rj | wj Uj described in Subsection 3.1, together with another similar scheduling
problem.

4 Application to the scheduling literature

In Subsection 2.2 and Subsection 3.2, we provided general formulations of problems satisfying
Additive and Composed DPAS recurrences. Next, we illustrate these recurrences with several
NP-hard single-machine scheduling problems enabling their resolution with our hybrid algorithm
Q-DDPAS. The list of problems is non-exhaustive but highlights the structures’ specificity of
scheduling problems that enable such recurrences. Eventually, for each problem, we compare
in Table 1 the worst-case time complexity of Q-DDPAS with the complexity of the best-known
moderate exponential-time exact algorithm. Q-DDPAS improves the exponential-part complex-
ity, sometimes at the cost of an additional pseudo-polynomial factor.

17
4.1 Scheduling with deadlines and precedence constraints

Single-machine scheduling problems with no constraints, deadline constraints or precedence

constraints satisfy the addition of optimal values of the problem on sub-instances. We provide
next several examples of problems that satisfy Additive DPAS and thus can be solved by Q-
DDPAS (Algorithm 1).
In Subsection 2.1, we have presented the problem of minimizing the total weighted comple-
tion time with deadline constraints (1|d˜j | j wj Cj ). The formulation needed the set T to be
P

equal to J0, nj=1 pj K, hence its resolution with Q-DDPAS is in O∗ ( pj · 1.728n ) according
P P

to Observation 2.9. Next, we give two more examples, beginning with the strongly NP-hard
scheduling problem with minimization of the total weighted tardiness. Henceforth, we note
P
p(J) = j∈J pj the sum of processing times of the jobs in J ⊆ [n].
P
Example 1 (Minimizing the total weighted tardiness, 1|| j wj Tj ). For each job j ∈ [n], we
are given a weight wj , a processing time pj , and a due date dj that indicates the time after
which the job is late. Thus, a job j is late in permutation π if its completion time is larger than
dj , and we define as Tj (π) = max(0, Cj (π) − dj ) its tardiness. Our problem aims at finding
P
the permutation that minimizes the total weighted tardiness, referred to as 1|| j wj Tj in the
scheduling literature. Let T = J0, nj=1 pj K be the set of all possible starting times. We define
P

the related problem P of Equation (4) as follows: for J ⊆ [n] and t ∈ T , Π(J, t) = SJ , and for
π ∈ Π(J, t):
X
f (π, J, t) = wj max(0, Cj (π) − dj + t) ,
j∈J

where max(0, Cj − dj + t) represents the tardiness of job j for the effective due date (dj − t).
P
Problem 1|| j wj Tj satisfies Additive DPAS recurrences. Indeed, Equation (Add-DPAS) is
valid with: ∀J ⊆ [n], ∀j ∈ J, ∀t ∈ T,

g(J, j, t) = wj max(0, p(J) − dj + t) ,

where the computation of g is polynomial (linear). Moreover, Equation (Add-D-DPAS) is valid

for the following functions: ∀X ⊆ J ⊆ [n] s.t. |X| = |J|/2, ∀t ∈ T,

τshift (J, X, t) = t + p(X) and h(J, X, t) = 0 ,

initialized by, for j ∈ [n] and t ∈ T , OPT[{j}, t] = wj max(0, pj − dj + t) .

We consider the scheduling problem with precedence constraints and minimization of the total
weighted completion time that is also NP-hard. Conversely to the two previous examples, the
set T is reduced to {0}, and function h translates the potential infeasibility of the concatenation

18
of problem P on two sub-instances.

Example 2 (Minimizing the total weighted completion time with precedence constraints,
P
1|prec| j wj Cj ). We are given, for each job j ∈ [n], a processing time pj , a weight wj , and a
set of precedence constraints K = {(i, j) : i ≺ j}. A pair of jobs (i, j) in K implies that i must
precede j in the permutation, namely that i must be processed before j. Our problem, denoted by
P
1|prec| j wj Cj , aims at finding the feasible permutation, i.e. that respects the precedence con-
straints, that minimizes the total weighted completion time. Let be T = {0}. Here, an instance
of the problem P of Equation (4) under consideration is only indexed by the chosen subset of [n].
Thus, we consider the problem P as follows: for J ⊆ [n], Π(J, 0) = {π ∈ SJ | π respects K} ,
P P
and for π ∈ Π(J, 0): f (π, J, 0) = j∈J wj Cj (π) . Our problem 1|prec| j wj Cj satisfies Additive
DPAS recurrences. Indeed, Equation (Add-DPAS) is valid for:

+∞

if ∃(j, k) ∈ E|k ∈ J
∀J ⊆ [n], ∀j ∈ J, g(J, j, 0) = ,
wj p(J)

otherwise

where the computation of g is polynomial (quadratic). Besides, Equation (Add-D-DPAS) is

valid for the following functions: ∀X ⊆ J ⊆ [n] such that |X| = |J|/2,

+∞ if ∃(j, k) ∈ E|j ∈ J \ X and k ∈ X


τshift (J, X, 0) = 0 and h(J, X, 0) = X

p(X) · wj otherwise

j∈J\X

where the computation of h is polynomial (quadratic). The initialization is, for j ∈ [n],
OPT[{j}, 0] = wj pj .

The three NP-hard scheduling problems examples described above can be solved with Q-
DDPAS for Additive DPAS (Algorithm 1). We illustrate in Table 2 the worst-case time complex-
ities of solving them with Q-DDPAS and compare them with the complexities of the best-known
exact classical algorithms. Q-DDPAS improves the complexity of the exponent but sometimes
at the cost of a pseudo-polynomial factor.

Problem Q-DDPAS for Additive DPAS Best classical algorithm

1|d˜j | O∗ ( pj · 1.728n ) O∗ (2n ) (T’kindt et al., 2022)

P P
wj Cj

O∗ ( pj · 1.728n ) O∗ (2n ) (T’kindt et al., 2022)

P P
1|| wj Tj

O∗ (1.728n ) O∗ ((2 − ϵ)n ), for small ϵ (Cygan et al., 2014)

P
1|prec| wj Cj

Table 2: Comparison of complexities between Q-DDPAS and the best-known classical algorithm
for some scheduling problems satisfying Additive DPAS recurrences.

19
4.2 Scheduling with release date constraints

Single-machine scheduling problems with release date constraints do not satisfy the addition
of optimal values of the problem on sub-instances but enable the composition of them. We
illustrate this notion with two examples of problems that satisfy Composed DPAS and thus can
be solved by Q-DDPAS (Algorithm 2).
We have presented in Subsection 3.1 an example that is the problem of minimizing the
P
weighted number of late jobs with release date constraints (1|rj | wj Uj ). We have shown that
the two sets to define the auxiliary problem are E = J0, nj=1 wj K and T = J0, nj=1 pj K∪{+∞}.
P P

Thus, Q-DDPAS solves this problem in O∗ ( wj )3 · pj · 1.728n according to Observa-

P P

tion 3.7. Next, we present another example which is the strongly NP-hard problem of min-
imizing the total weighted completion time with release date constraints.

Example 3 (Minimizing the total weighted completion time with release date constraints,
P
1|rj | wj Cj ). Each job j ∈ [n] has a weight wj , a processing time pj , and a release date rj . This
problem aims at finding the feasible permutation, namely where each job starts after its release
date, for which the total weighted completion time is minimal. Let T = J0, nj=1 pj K ∪ {+∞}
P

and E = J0, nj=1 wj · nj=1 pj K. For a given ϵ ∈ E, we consider the problem P ′ of Equation (5)
P P

as follows: ∀J ⊆ [n], t ∈ T,
P ′ (J, t, ϵ) : min Cmax (π) ,
π∈Π′ (J,t,ϵ)

where Cmax is the makespan, and

X
Π′ (J, t, ϵ) = {π ∈ SJ : Cj (π) ≥ max(t, rj ) + pj and wj Cj (π) = ϵ} ,
j∈J

where Cj is the completion time of job j. Problem P ′ satisfies Composed DPAS recur-
rences (Comp-DPAS) and (Comp-D-DPAS). The initialization of the recurrences is, for
j ∈ [n], t ∈ T and ϵ ∈ E,

Cj := max(t, rj ) + pj ,

if ϵ = wj Cj
OPT[{j}, t, ϵ] =

+∞, otherwise

We synthesize in Table 3 the worst-case time complexities achieved by Q-DDPAS on the

examples of scheduling problems satisfying Composed DPAS recurrences. We compare them
with the best-known classical complexities for exact algorithms. The latter comes from the al-
gorithm of Inclusion-Exclusion designed by Ploton and T’kindt (2022), which provides a generic
method to solve such problems. We observe that Q-DDPAS improves the exponential part of
the complexity, at a cost of a higher degree for the pseudo-polynomial factor.

20
 Problem Q-DDPAS for Composed DPAS Best classical algorithm

O∗ ( O∗ (


wj )3 · pj · 1.728n pj · 2n ) , (Ploton and T’kindt, 2022)
P P P P P
1|rj | wj Uj wj ·

O∗ ( wj )3 · ( pj )4 · 1.728n O∗ (


wj · ( pj )2 · 2n ) , (Ploton and T’kindt, 2022)
P P P P P
1|rj | wj Cj

Table 3: Comparison of complexities between Q-DDPAS and the best-known classical algorithm
for some scheduling problems satisfying Composed DPAS recurrences.

5 Decision-based DPAS

We saw in the previous section that the recurrence to solve P can be applied to a minimization
problem, possibly involving an auxiliary problem. Sometimes, the recurrence does not apply
directly to a minimization problem but to a decision problem. This is the case of the 3-machine
flowshop problem. In this section, we adapt the hybrid algorithm Q-DDPAS to solve this
problem. Notice that it easily generalizes to the m-flowshop problem, for m ≥ 4.

5.1 3-machine flowshop and dynamic programming

We consider the permutation flowshop problem on 3 machines for n jobs with minimizing the
makespan as the objective function. This strongly NP-hard problem is often referred to as
F 3||Cmax in the literature, as mentioned by Shang et al. (2018). Each job j ∈ [n] consists of 3
operations Oij for i ∈ [3], each operation being processed on the i-th machine. We note pij the
processing time of operation Oij . Each machine performs at most one operation at a time. For
each job j, operations must be processed in the specific order O1j , O2j , O3j : the first operation
gets processed on the first machine, then the second operation gets processed on second machine
(as soon as the first operation is finished and the second machine is available), and eventually
the third operation gets processed on the third machine (as soon as the second operation is
finished and the third machine is available). Thus, only the processing order of the jobs has
to be decided, implying that a solution is entirely described by the permutation of jobs on the
first machine. Thus, the problem can be formulated as

min Cmax (π) , (7)

π∈S[n]

where Cmax is the maximum completion time, namely the completion time of the last job
processed on the last machine (third machine). Because the two techniques presented so far do
not apply to (7), we present an alternative approach involving the decision counterpart of the
above optimization problem.
We introduce below a decision problem for deriving the recurrences. For that, we define the

21
bounded set u }
X
T = v0, pij ~ ⊆ Z .
j∈[n],i∈[3]

Definition 5.1 (Decision problem). For J ⊆ [n], β⃗ = (β2 , β3 ) ∈ T 2 and ⃗ϵ = (ϵ2 , ϵ3 ) ∈ T 2 ,

⃗ ϵ) on a sub-instance associated with jobs in J as the
we define the decision problem D(J, β,⃗
following question: “Does there exist a permutation π ∈ SJ such that, for i ∈ {2, 3}, bi (π) ≥ βi ,
and ei (π) ≤ ϵi ?”, where bi (π), respectively ei (π), denotes the time at which the first operation
begins, respectively the last operation ends, on the i-th machine.

⃗ ϵ) asks whether or not there exists a feasible permutation

In other words, problem D(J, β,⃗
with jobs in J such that it holds between the two temporal fronts β⃗ and ⃗ϵ. Notice that it is not
necessary to impose any beginning and ending time for the first machine (i = 1). Indeed, the
problem is time-invariant, thus we can always consider that the scheduling problem starts at
time 0, and that the total completion time on the first machine is known and equal to the sum
of processing times of the scheduled jobs. Notice that the number of parameters is four for the
3-machine flowshop, but generalizes to 2(m − 1) parameters for the m-machine flowshop.
With these notations, P can be cast as follows:
n o
P: min c : D[[n], (0, 0), (c, c)] = True . (8)
c∈T

The decision problem D satisfies (Dec-DPAS) and (Dec-D-DPAS) recurrences below.

Property 5.2 (Decision DPAS). For all J ⊆ [n] of even cardinality, β⃗ ∈ T 2 and ⃗ϵ ∈ T 2 ,
_  
⃗ ϵ] =
D[J, β,⃗ ⃗ ⃗t] ∧ D[J \ {j}, ⃗t ⊖ p1j ,⃗ϵ ⊖ p1j ] ,
D[{j}, β, (Dec-DPAS)
X⊆J:|X|=|J|/2,
⃗ ⃗ ϵ]
t∈[β,⃗

⃗ ϵ] means that the i-th coordinate of ⃗t is between the i-th coordinates of β⃗ and ⃗ϵ,
where ⃗t ∈ [β,⃗
and where operation ⃗v ⊖ c, for a vector ⃗v and a constant c, subtracts c to each coordinate of ⃗v .

This latter recurrence enables P to be solved by a classical dynamic programming algorithm.

Lemma 5.3. (Dec-DPAS) solves P in O∗ (|T |4 · 2n ).

Proof. First, we can show that, for a given β⃗0 ,⃗ϵ0 ∈ T 2 , (Dec-DPAS) solves D([n], β⃗0 ,⃗ϵ0 ) in
O∗ (|T |4 · 2n ). This is essentially the same lines of the proof as in Lemma 2.2. Second, to solve
P, we make a dichotomic search over T to find the minimum c ∈ T such that D([n], (0, c), (0, c))
is True according to Equation (8). Thus, (Dec-DPAS) is called log2 (|T |) times. Because |T | =
pij is a pseudo-polynomial term of the instance, the total complexity is O∗ (log2 (|T |) · |T |4 ·
P

2n ) = O∗ (|T |4 · 2n ) .

22
Property 5.4 (Decision Dichotomic DPAS). For all J ⊆ [n] of even cardinality, β⃗ ∈ T 2 and
⃗ϵ ∈ T 2 ,
 
_ X X
⃗ ϵ] =
D[J, β,⃗ ⃗ ⃗t] ∧ D[J \ X, ⃗t ⊖
D[X, β, p1j ,⃗ϵ ⊖ p1j ] . (Dec-D-DPAS)
X⊆J:|X|=|J|/2, j∈X j∈X
⃗ ⃗ ϵ]
t∈[β,⃗

Lemma 5.5. (Dec-D-DPAS) solves P in ω(|T |4 · 2n ).

Proof. This proof is similar to the proof of Lemma 2.5, with the argument that a dichotomic
search is polynomial in the size of the instance as in the proof of Lemma 5.3.

Once again, we observe that recurrence (Dec-DPAS) outperforms recurrence (Dec-D-DPAS)

to solve by classical dynamic programming our problem P. In the next subsection, we describe
how we adapt Q-DDPAS to take advantage of those two recurrences to solve the 3-machine
flowshop problem.

5.2 Hybrid algorithm for Decision-based DPAS

We call Q-Dec-DDPAS the adapted decision version of Q-DDPAS. The main difference
is that instead of searching for a minimum value in a set in recurrence (Add-D-DPAS)
or (Comp-D-DPAS), we search for a True value in a set in recurrence (Dec-D-DPAS). Thus,
it essentially amounts to replacing Quantum Minimum Finding with the algorithm of Boyer
et al. (1998) specified below, which extends Grover Search (Grover, 1996).

Definition 5.6 (Grover Search Extension (Boyer et al., 1998)). Let f : [n] → {0, 1} be a
function. Grover Search Extension computes with high probability the logical OR of all the f
values and the corresponding antecedent(s) x ∈ [n] such that f (x) = 1. The complexity of
√
Grover Search Extension is O ( n · Cf (n)), where O(Cf (n)) is the complexity of computing a
value of f .

Notice that we cannot use Grover Search because we do not know the number of x such that
f (x) = 1. The generalization of Boyer et al. (1998) enables us to deal with an unknown number
of solutions while keeping the same complexity of Grover Search. Moreover, if there are t ∈ N∗
p 
solutions, the complexity is O n/t · Cf (n) but, having no bounds on t whenever we call
Grover Search Extension, we omit it in the complexity.

Lemma 5.7. Let β⃗0 ,⃗ϵ0 ∈ T 2 . The bounded-error algorithm Q-Dec-DDPAS (Algorithm 4) solves
D([n], β⃗0 ,⃗ϵ0 ) in O∗ (( pij )4 · 1.754n ).
P

23
 Algorithm 4: Q-Dec-DDPAS for 3-machine flowshop
Input: β⃗0 ,⃗ϵ0 ∈ T 2 , decision problem D satisfying Decision DPAS recurrences
Output: D[[n], β⃗0 ,⃗ϵ0 ] with high probability
begin classical part
⃗ ϵ ∈ T 2 do
for X ⊆ [n] : |X| = n/4 and β,⃗
⃗ ϵ] with (Dec-DPAS) and store the results in the QRAM;
Compute D[X, β,⃗

begin quantum part

Apply Grover Search Extension with (Dec-D-DPAS) to find D[[n], β⃗0 ,⃗ϵ0 ];
⃗ ϵ] for
To get values for the Grover Search Extension above (the values D[J, β,⃗
⃗ ϵ ∈ T ), apply Grover Search Extension
J ⊆ [n] of size n/2 and β,⃗
with (Dec-D-DPAS);
To get values for Grover Search Extension above (the values D[X, β⃗ ′ ,⃗ϵ′ ] for X ⊆ [n]
of size n/4 and β⃗ ′ ,⃗ϵ′ ∈ T ), get them on the QRAM;

The proof is essentially the same as for Theorem 2.8, detailed in Supplementary Materi-
als. All the details of correctness and low-level implementation are given in our companion
paper (Grange et al., 2024).

Algorithm 5: Algorithm with subroutine Q-Dec-DDPAS for the 3-machine flowshop

Input: 3-machine flowshop
Output: Minimum makespan with high probability
c∗ ← +∞;
for c ∈ T do
Solve D([n], (0, 0), (c, c)) with Algorithm 4;
if D[[n], (0, 0), (c, c)] and c < c∗ then
c∗ ← c;

Return c∗

Theorem 5.8. The bounded-error Algorithm 5 solves the 3-machine flowshop in O∗ (( pij )4 ·
P

1.754n ) with high probability.

Once again, as mentioned in Observation 2.9, the complexity can be reduced thanks to a
slight modification on the Q-Dec-DDPAS that constitutes the subroutine, thus leading to the
following observation.

24
Observation 5.9. A slight modification of Algorithm 5 reduces the complexity of solving the
3-machine flowshop in O∗ (( pij )4 · 1.728n ) with high probability.
P

This new method improves the best-known classical algorithm that is in O∗ (3n ) or in O∗ (M ·
2n ) if there exists a constant M such that pij ≤ M , for all i ∈ [3], j ∈ [n], presented by Shang
et al. (2018) and Ploton and T’kindt (2023). Hybrid quantum-classical bounded-error Algo-
rithm 5 reduces the exponential part of the time complexity at the cost of a pseudo-polynomial
factor. For most cases, this factor is negligible because the numerical values of 3-machine flow-
shop instances are small compared to the exponential part value. However, we present in the
next subsection a way to dispose of this factor with an approximation scheme.
It is worth noting that the previous algorithm easily generalizes to the m-machine flowshop
problem. Indeed, the only difference is the description of the temporal front that necessitates
2(m − 1) parameters.

Observation 5.10. The bounded-error Algorithm 5 generalizes to solve the m-machine flowshop
in O∗ (( pij )2(m−1) · 1.728n ) with high probability.
P

Notice that Ploton and T’kindt (2023) present a classical resolution for the m-machine flow-
shop by Inclusion-Exclusion in O∗ (( pij )m · 2n ).
P

5.3 Approximation scheme for the 3-machine flowshop

We present an approximation scheme for the 3-machine flowshop problem that trades the
pseudo-polynomial factor in the complexity of Q-Dec-DDPAS and the optimality of the al-
1
gorithm for a polynomial factor in and an approximation factor of (1 + ϵ). In other words,
ϵ

we provide Algorithm 6 that finds a solution in time O∗ ϵ13 · 1.728n for which the makespan

is not greater than (1+ϵ) times the optimal makespan. The latter point denotes that this is an
ϵ-approximation scheme. Our algorithm belongs to the class of moderate exponential-time ap-
proximation algorithms. Notice that the 3-machine flowshop problem does not admit an FPTAS
(fully polynomial-time approximation scheme) because it is strongly NP-hard, meaning that no
ϵ-approximation algorithm exists to solve the 3-machine flowshop in time O poly(n, 1ϵ ) unless

P = NP (Vazirani, 2001). In comparison, Hall (1998) provides for the m-machine flowshop prob-
lem an FPT-AS (fixed-parameter tractable approximation scheme), namely an ϵ-approximation
algorithm that runs in time O(f (ϵ, κ) · poly(n)) for κ a fixed parameter of the instance and f
a computable function. Hall (1998) choose 
κ to be the number
 of machines of the flowshop,
m4
leading to an FPT-AS that runs in time O n3.5 · ( m
ϵ )
ϵ2 . In our case, we consider the case
m = 3.

25
 Algorithm 6: Hybrid approximation scheme for the 3-machine flowshop
Input: ϵ > 0, 3-machine flowshop on n jobs with processing times {pij : i ∈ [3], j ∈ [n]}
Output: solution at most 1 + ϵ times the optimal solution
1 P = max {pij };
i∈[3],j∈[n]
ϵP
2 K= n+2 ;

3 for i ∈ [3], j ∈ [n] do

p
4 p′ij = ⌈ Kij ⌉;

5 Solve the 3-machine flowshop on n jobs with new processing times {p′ij : i ∈ [3], j ∈ [n]}
with Algorithm 5 that outputs permutation π ′ ;
6 Return π ′

Lemma 5.11. Let π ∗ be an optimal solution of the 3-machine flowshop problem, for the pro-
cessing times {pij : i ∈ [3], j ∈ [n]}. Let π ′ be the output of Algorithm 6. We have

Cmax (π ′ ) ≤ (1 + ϵ) · Cmax (π ∗ ) .

Next, we introduce two observations necessary to prove Lemma 5.11. The proofs are omitted
because of their simplicity.

Observation 5.12. Let π be a permutation and let be α ∈ R∗+ . We note Cmax (π) the makespan
′
of π of the 3-machine flowshop for processing times {pij : i ∈ [3], j ∈ [n]}. We note Cmax (π)
the makespan of π of the 3-machine flowshop for processing times {p′ij : i ∈ [3], j ∈ [n]} such
that p′ij := αpij for all i, j. Then, Cmax
′ (π) = αCmax (π) . Notice that for p′ij ≤ αpij , we have
′
Cmax ′
(π) ≤ αCmax (π) even if the critical path in π may differ to obtain Cmax and Cmax .

Observation 5.13. Let π be a permutation and let β ∈ R such that β ≥ − min {pij }.
i∈[3],j∈[n]
We note Cmax (π) the makespan of π of the 3-machine flowshop for processing times {pij : i ∈
′′ (π) the makespan of π of the 3-machine flowshop for processing
[3], j ∈ [n]}. We note Cmax
times {p′′ij : i ∈ [3], j ∈ [n]} such that p′′ij := pij + β for all i ∈ [3], j ∈ [n]. Then, Cmax
′′ (π) ≤

Cmax (π) + β(n + 2) . Notice that for p′′ij ≤ pij + β, we still have Cmax
′′ (π) ≤ C
max (π) + β(n + 2)
′′ .
even if the critical path in π may differ to obtain Cmax and Cmax

p
Proof of Lemma 5.11. Let be ϵ > 0. The new processing times considered p′ij := ⌈ Kij ⌉ imply
pij pij
that K ≤ p′ij < K
′
+ 1. We note Cmax the makespan of the new problem, i.e. the 3-machine
flowshop problem with processing times {p′ij : i ∈ [3], j ∈ [n]}.
pij
On the one hand, we have p′ij < K + 1, for all i ∈ [3], j ∈ [n]. Thus, according to Obser-
Cmax (π ∗ )
vations 5.12 and 5.13 considering the optimal permutation π ∗ , Cmax
′ (π ∗ ) ≤ K + n + 2,

26
namely, because K > 0,
′
KCmax (π ∗ ) ≤ Cmax (π ∗ ) + K(n + 2) . (9)
pij
On the other hand, we have K ≤ p′ij . Thus, according to Observation 5.12 considering the
Cmax (π ′ )
output permutation π ′ of Algorithm 6, K
′
≤ Cmax (π ′ ) , namely, because K > 0,

Cmax (π ′ ) ≤ KCmax
′
(π ′ ) ≤ KCmax
′
(π ∗ ) (10)

≤ Cmax (π ∗ ) + K(n + 2) = Cmax (π ∗ ) + ϵP (11)

≤ Cmax (π ∗ ) + ϵCmax (π ∗ ) = (1 + ϵ)Cmax (π ∗ ) , (12)

where (10) comes from the fact that π ′ is the optimal solution for makespan Cmax
′ , (11) re-
sults from Equation (9), and (12) is true because the makespan is always larger than P =
max {pij }.
i∈[3],j∈[n]

Theorem 5.14. Algorithm 6 is an approximation scheme for the 3-machine flowshop problem
and outputs a solution whose makespan it at most (1 + ϵ) times the optimal value in time
O∗ ϵ13 · 1.728n .

Proof. First, according to Lemma 5.11, Algorithm 6 outputs a solution whose makespan it at
most (1 + ϵ) times the optimal value. Second, Algorithm 5 solves the new problem in time
O∗ (( p′ij )4 · 1.728n ) = O∗ ( ϵ14 · 1.728n ). Indeed,
P

X X  pij  1 X 1 3n(n + 2)
p′ij ≤ +1 = pij + 3n ≤ · 3nP + 3n = + 3n .
K K K ϵ
p′ij ≤ poly(n, 1ϵ ).
P
Thus,

6 Conclusion

In this work, we propose generalized dynamic programming recurrences for NP-hard scheduling
problems to solve a broad class of such problems with our hybrid algorithm Q-DDPAS which is
an adapted version of the quantum-classical algorithm of Ambainis et al. (2019). Q-DDPAS pro-
vides a quantum speed-up to their exact resolution. Specifically, our hybrid algorithm reduces
the best-known classical time complexity, often equal to O∗ (2n ) for single-machine problems
and O∗ (3n ) for the 3-machine flowshop, to O∗ (1.728n ), sometimes at the cost of an additional
pseudo-polynomial factor. Notice that these theoretical results cannot be implemented on cur-
rent quantum computers yet, because they are too noisy and do not have QRAM. While waiting
for more mature machines, future work will be dedicated to widening the range of problems
for which we can achieve a quantum speed-up, e.g. considering scheduling objective function
not tackled in this paper, such as the maximum lateness. This will necessitate finding NP-hard

27
problems for which the description of a solution is a permutation, and that satisfy a dynamic
programming property admitting a dichotomic version, relying either on an optimization or a
decision problem. A first lead is to consider the 3-machine jobshop problem. Indeed, a promis-
ing description of a solution of this problem is the Bierwith vector (Bierwirth, 1995), a vector
encoding a solution as a permutation with repetition of size 3n, where n is the number of jobs.

Acknowledgements. This work has been partially financed by the ANRT through the PhD
number 2021/0281 with CIFRE funds.

Bibliography

Ambainis, A., Balodis, K., Iraids, J., Kokainis, M., Prūsis, K., and Vihrovs, J. (2019). Quan-
tum speedups for exponential-time dynamic programming algorithms. In Proceedings of the
Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 1783–1793. SIAM.

Bernstein, E. and Vazirani, U. (1993). Quantum complexity theory. In Proceedings of the

twenty-fifth annual ACM symposium on Theory of computing, pages 11–20.

Bierwirth, C. (1995). A generalized permutation approach to job shop scheduling with genetic
algorithms. Operations-Research-Spektrum, 17(2):87–92.

Boyer, M., Brassard, G., Høyer, P., and Tapp, A. (1998). Tight bounds on quantum searching.
Fortschritte der Physik: Progress of Physics, 46(4-5):493–505.

Cerezo, M., Arrasmith, A., Babbush, R., Benjamin, S. C., Endo, S., Fujii, K., McClean, J. R.,
Mitarai, K., Yuan, X., Cincio, L., et al. (2021). Variational quantum algorithms. Nature
Reviews Physics, 3(9):625–644.

Cygan, M., Pilipczuk, M., Pilipczuk, M., and Wojtaszczyk, J. O. (2014). Scheduling partially
ordered jobs faster than 2n . Algorithmica, 68:692–714.

Dürr, C. and Høyer, P. (1996). A quantum algorithm for finding the minimum. arXiv preprint
quant-ph/9607014.

Farhi, E., Goldstone, J., and Gutmann, S. (2014). A quantum approximate optimization algo-
rithm. arXiv preprint arXiv:1411.4028.

Giovannetti, V., Lloyd, S., and Maccone, L. (2008). Quantum random access memory. Physical
review letters, 100(16):160501.

28
Graham, R. L., Lawler, E. L., Lenstra, J. K., and Kan, A. R. (1979). Optimization and
approximation in deterministic sequencing and scheduling: a survey. In Annals of discrete
mathematics, volume 5, pages 287–326. Elsevier.

Grange, C., Bourreau, E., Poss, M., and t’Kindt, V. (2023a). Quantum speed-ups for single-
machine scheduling problems. In Proceedings of the Companion Conference on Genetic and
Evolutionary Computation, pages 2224–2231.

Grange, C., Poss, M., and Bourreau, E. (2023b). An introduction to variational quantum
algorithms for combinatorial optimization problems. 4OR, pages 1–41.

Grange, C., Poss, M., Bourreau, E., t’Kindt, V., and Ploton, O. (2024). Companion Paper:
Moderate Exponential-time Quantum Dynamic Programming Across the Subsets for Schedul-
ing Problems. HAL preprint, [Link]

Grover, L. K. (1996). A fast quantum mechanical algorithm for database search. In Proceedings
of the twenty-eighth annual ACM symposium on Theory of computing, pages 212–219.

Hall, L. A. (1998). Approximability of flow shop scheduling. Mathematical Programming, 82(1-

2):175–190.

Held, M. and Karp, R. M. (1970). The traveling-salesman problem and minimum spanning
trees. Operations Research, 18(6):1138–1162.

Kurowski, K., Pecyna, T., Slysz, M., Rozycki, R., Waligora, G., and Weglarz, J. (2023). Ap-
plication of quantum approximate optimization algorithm to job shop scheduling problem.
European Journal of Operational Research, 310(2):518–528.

Lawler, E. L. (1990). A dynamic programming algorithm for preemptive scheduling of a single

machine to minimize the number of late jobs. Annals of Operations Research, 26:125–133.

Miyamoto, M., Iwamura, M., Kise, K., and Gall, F. L. (2020). Quantum speedup for the
minimum steiner tree problem. In COCOON 2020, Atlanta, GA, USA, August 29–31, 2020,
Proceedings, pages 234–245. Springer.

Nannicini, G. (2019). Performance of hybrid quantum-classical variational heuristics for com-

binatorial optimization. Physical Review E, 99(1):013304.

Nannicini, G. (2022). Fast quantum subroutines for the simplex method. Operations Research.

Pinedo, M. L. (2012). Scheduling, volume 29. Springer.

29
Ploton, O. and T’kindt, V. (2022). Exponential-time algorithms for parallel machine scheduling
problems. Journal of Combinatorial Optimization, 44(5):3405–3418.

Ploton, O. and T’kindt, V. (2023). Moderate worst-case complexity bounds for the permutation
flowshop scheduling problem using inclusion–exclusion. Journal of Scheduling, 26(2):137–145.

Ruan, Y., Marsh, S., Xue, X., Liu, Z., Wang, J., et al. (2020). The quantum approximate
algorithm for solving traveling salesman problem. CMC, 63(3):1237–1247.

Shang, L., Lenté, C., Liedloff, M., and T’Kindt, V. (2018). Exact exponential algorithms for
3-machine flowshop scheduling problems. Journal of Scheduling, 21:227–233.

Shimizu, K. and Mori, R. (2022). Exponential-time quantum algorithms for graph coloring
problems. Algorithmica, pages 1–19.

Sutter, D., Nannicini, G., Sutter, T., and Woerner, S. (2020). Quantum speedups for convex
dynamic programming. arXiv preprint arXiv:2011.11654.

Tabi, Z., El-Safty, K. H., Kallus, Z., Hága, P., Kozsik, T., Glos, A., and Zimborás, Z. (2020).
Quantum optimization for the graph coloring problem with space-efficient embedding. In
2020 IEEE (QCE), pages 56–62. IEEE.

T’kindt, V., Della Croce, F., and Liedloff, M. (2022). Moderate exponential-time algorithms
for scheduling problems. 4OR, pages 1–34.

Vazirani, V. V. (2001). Approximation algorithms, volume 1. Springer.

Woeginger, G. J. (2003). Exact algorithms for np-hard problems: A survey. In Combinatorial

Optimization—Eureka, You Shrink! Papers, pages 185–207. Springer.

A Useful upper bounds

We define the binary entropy of ϵ ∈]0, 1[ by H(ϵ) = −(ϵ log2 (ϵ) + (1 − ϵ) log2 (1 − ϵ)) . We remind
some useful upper bounds of binomial coefficients Ambainis et al. (2019):
  k  
n k n k
r nz
≤ 2H ( n )·n , ∀k ∈ J1, nK ≤ 2H ( n )·n , ∀k ∈ 1,
X
and .
k i 2
i=1

Thus, it leads to the following upper bounds to compute the complexities of interest:
n/4   0.945·n/4  
s   s   
X n 0.811n
X n 0.789n n n/2 0.75n n n/2 n/4
≤2 , ≤2 , ≤2 , ≤ 20.789n
k k n/2 n/4 n/2 n/4 0.945 · n/4
i=k k=1

30