Computing the worst-case due dates violations with

budget uncertainty
Igor Malheiros, Artur Pessoa, Michael Poss, Anand Subramanian

To cite this version:

Igor Malheiros, Artur Pessoa, Michael Poss, Anand Subramanian. Computing the worst-case due
dates violations with budget uncertainty. Operations Research Letters, In press. �hal-04351032v3�

HAL Id: hal-04351032

https://hal.science/hal-04351032v3
Submitted on 23 Jul 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.
 Computing the worst-case due dates violations with budget uncertainty

Igor Malheirosa,b , Artur Pessoac , Michaël Possa , Anand Subramaniand

a LIRMM, Université de Montpellier, CNRS, Rue Ada 156, 34095, Montpellier, France
b Atoptima, Rue Marc Sangnier 2, Bègles, 33130, France
c TEP, Universidade Federal Fluminense, Rua Passo da Pátria, 156, 24210-240, Niterói, Brazil
d DSC, Universidade Federal da Paraı́ba, Rua dos Escoteiros s/n, 58055-000, João Pessoa, Brazil

Abstract
We study the problem of maximizing the violation of due dates when considering either the total violation, or
the number of jobs that are tardy. We consider classical completion times and a variant useful in heuristics.
The four problems arise when solving (exactly or heuristically) robust scheduling problems with release and due
dates/deadlines and processing time uncertainty, and also routing problems with (soft) time windows and travel time
uncertainty. We provide polynomial dynamic programming algorithms for the four problems.
Keywords: robust optimization, release date, due date, deadlines, budget uncertainty

1. Introduction for each i ∈ {2, . . . , n}. The innermost minimum sets

the completion time back to di−1 in case violation oc-
We consider a set of n jobs scheduled in the order curs, the so-called time-warp, while the inner maximum
[n] = {1, 2, . . . , n}. For each job, we are given a release models the waiting time as in the basic model.
date ri , a due date di , a nominal processing time p̄i and a For each of these two models M ∈ {B, T W}, we seek
deviation p̂i . The actual processing time of job i is given to maximize the total violation
by p̄i + δi p̂i , where δi ∈ {0, 1} is a binary optimization X
variable that satisfies the constraint f (tiM (δ) − di ),
X i∈[n]
δi ≤ Γ, (1)
i∈[n] for two choices of functions f :

for a given positive integer Γ. The goal of the opti- • f0 (x) = 0 for x ≤ 0 and f0 (x) = 1 for x > 0;
mization problems studied in this paper is to find a bi-
• f1 (x) = max(0, x), also denoted by (x)+ ;
nary δ satisfying (1) that maximizes the violation of
due
n dates. In P what follows,o we use the notation ∆Γ = where f0 indicates whether a job is tardy (or fails) while
δ ∈ {0, 1}n i∈[n] δi ≤ Γ to represent the feasibility f1 considers the tardiness of the job. We denote the re-
set of δ, which is widely used in the robust routing and sulting functions of δ as ϕiM (δ) = f0 (tiM (δ) − di ) and
scheduling literature, e.g. [1, 2, 3, 4, 5]. τiM (δ) = f1 (tiM (δ) − di ), and ϕ M (δ) = i∈[n] ϕiM (δ) and
P
We consider more specifically two models for com- τ M (δ) = i∈[n] τiM (δ), respectively. Therefore, this pa-
P
puting the completion times of each job. In the basic per studies the optimization problems defined on set ∆Γ ,
model, the completion time of job i, denoted tiB (δ), is for the objective functions τB , τT W , ϕB , and ϕT W .
given by t1B (δ) = r1 + p̄1 + δ1 p̂1 and
1.1. Motivation
tiB (δ) = max(ti−1
B
(δ), ri ) + p̄i + δi p̂i , (2)
Basically, the four optimization problems studied in
for each i ∈ {2, . . . , n}. Observe that the maximum in (2) this paper are motivated by the exact and heuristic solu-
models the wait until ri in case job i − 1 is completed tion of robust scheduling problems with release and due
earlier than ri . In the time-warp model, the completion dates/deadlines and processing time uncertainty, and
time is given by t1T W (δ) = r1 + p̄1 + δ1 p̂1 and also robust routing problems with (soft) time windows
and travel time uncertainty. Let us start with model B
tiT W (δ) = max(min(ti−1
TW
(δ), di−1 ), ri ) + p̄i + δi p̂i , (3) and consider a robust scheduling problem seeking to
Preprint submitted to Operations Research Letters July 23, 2024
minimize the tardiness. One exact approach to such functions ϕB and ϕT W as they involve counting the num-
problems is based on a row-and-column generation al- ber of times a strict inequality holds, which is typically
gorithm [6], the separation problem of which corre- difficult to model with MILPs.
sponds exactly to maximizing τB , see [4]. Similar mod- The contribution of this work is thus to prove that
els arise in the vehicle routing literature with release and these four problems are polynomially solvable, propos-
due dates, where one wishes to minimize the total tar- ing three different dynamic programming algorithms
diness [7, 8]. Hence, the separation problems studied detailed in the following three sections. While the al-
herein could be leveraged to develop algorithms also for gorithms for τB and τT W rely on different ideas, pre-
the robust counterparts of the above routing problems. sented in Sections 3 and 4, respectively, those for ϕB
The above row-and-column generation algorithm could and ϕT W are nearly identical for the two models, and
be extended to the problem minimizing the number of presented in the following section. Section 5 concludes
tardy jobs, proved NP-hard in [9], which leads to max- with short numerical experiments, comparing our algo-
imizing ϕB . rithm for optimizing τB with the straightforward MILP
Second, these scheduling problems, as well as their formulation.
routing counterparts, are also often addressed heuristi-
cally through local search algorithms [10]. In this case, 2. Number of tardy jobs
one needs to compute the objective of the schedules and
routes explored by the algorithm, which amounts again The total number of tardy jobs among the n jobs is
to maximizing τB and ϕB . Model T W is useful in lo- bounded by n. This allows one to design a dynamic
cal search algorithms applied to scheduling and routing programming algorithm to compute V(i, γ, α), the max-
problems with release dates and deadlines, also called imum completion time of job i given that α ∈ [i] jobs
time windows in the routing literature. Because the in [i] are tardy and using γ ∈ [Γ] ∪ {0} deviations so far.
search algorithm frequently evaluates modifications on Notice that we set value V(i, γ, α) to −∞ if it is impossi-
the current schedules/paths, it is crucial to design ef- ble to get α ∈ [i] jobs tardy among the jobs of [i] using
ficient methods to assess violation levels. A popular γ ∈ [Γ] ∪ {0} deviations.
approach is to evaluate this violation without accumu- We start with the initial condition that V(i, γ, α) =
lating the delays along the entire path, known as time- −∞ if α > i as well as V(i, γ, α) = −∞ if γ > i. Then,
warp relaxation. This is because the time-warp of a the recursion returning the value of V(i, γ, α) is split into
path can be efficiently computed through operations on different cases, depending on the value of i, γ, α. We
observe that each state’s definition depends on which
the time-warp of its sub-paths. Since classical neighbor-
predecessors of the state exist in the recursion. To sim-
hood moves involve a bounded number of sub-path per- plify the conditions on the predecessors’ existence, we
mutations, preprocessing all sub-path delays allows for exploit the value −∞ for states that cannot be reached.
their reuse during the search. This avoids recomputing Specifically, “if V(i, γ, α) + x ≥ y” for some values x
the time-warp from scratch each time, see [11, 12]. As- and y is actually equivalent to “if state (i, γ, α) can be
sessing the violation of the current solution without ac- reached and V(i, γ, α) + x ≥ y”. We also introduce ab-
cumulation leads to the maximization of functions τT W solute values to obtain similar simplifications for condi-
and ϕT W . tions that involve upper bounds: “if |V(i, γ, α)| + x ≥ y”
for some values x and y is actually equivalent to “if state
(i, γ, α) can be reached and V(i, γ, α) + x ≥ y”.
1.2. Contributions
i = 1 and γ = 0 and α = 0:
Checking whether the optimal solution cost of any 
if r1 + p̄1 ≤ d1 : r1 + p̄1


of the four problems is equal to 0 can be answered in 
else :
 −∞
polynomial time by using the dynamic programming al-
gorithm proposed in [1], and subsequently leveraged to i = 1 and γ = 0 and α = 1:

provide compact formulations for routing and schedul- if r1 + p̄1 ≤ d1 : −∞


ing problems with deadlines [2, 3]. However, prior to r + p̄

else :

1 1
this paper, it was unknown whether optimizing func- i = 1 and γ = 1 and α = 0:
tions τB , τT W , ϕB , and ϕT W could be done in polynomial 
if r1 + p̄1 + p̂1 ≤ d1 : r1 + p̄1 + p̂1


time, and these were typically solved by using dynamic 
else :
 −∞
programming algorithms running in pseudo-polynomial
time [13, 14, 4]. While functions τB and τT W could i = 1 and γ = 1 and α = 1:

alternatively be optimized by mixed-integer linear pro- if r1 + p̄1 + p̂1 ≤ d1 : −∞


gramming (MILP) formulations, this is not the case of r1 + p̄1 + p̂1

else :


2
i ≥ 2 and γ = 0 and α = 0: ϕT W . In this case, it is enough to replace the value of
 V(i, γ, α) by di when a failure occurs at a given job.
if |V(i − 1, 0, 0)| + p̄i ≤ di : max{ri , V(i − 1, 0, 0) + p̄i }


 We discuss next the possible generalization of the
else:
 −∞
aforementioned algorithm to the weighted number of
i ≥ 2 and γ = 0 and 1 ≤ α ≤ i: tardy jobs. Specifically, given a tuple of non-negative
integers w, we introduce the weighted number of tardy


if V(i − 1, 0, α − 1) + p̄i > di : V(i − 1, 0, α − 1) + p̄i
jobs as ϕwB (δ) = i∈[n] wi ϕiB (δ). One readily verifies that,

 P
elsif |V(i − 1, 0, α)| + p̄i ≤ di : max{ri , V(i − 1, 0, α) + p̄i }



extending the above dynamic programming algorithm



else :
 −∞
to this case, α represents the weight of the tardy jobs,
i ≥ 2 and 1 ≤ γ ≤ i and α = 0: P
which is bounded above by i wi . Hence, the complex-
 P



if |V(i − 1, γ, 0)| + p̄i ≤ di and ity of the resulting algorithm is O(nΓ i wi ), which is




 |V(i − 1, γ − 1, 0)| + p̄i + p̂i ≤ di : polynomially bounded only when wi are assumed con-





 max{ri , V(i − 1, γ, 0) + p̄i , V(i − 1, γ − 1, 0) + p̄i + p̂i } stant. We show next that when this latter assumption is
removed, the problem becomes NP-hard.


elsif |V(i − 1, γ − 1, 0)| + p̄i + p̂i ≤ di :








 max{ri , V(i − 1, γ − 1, 0) + p̄i + p̂i } Proposition 1. Maximizing ϕwB (δ) over ∆Γ is NP-hard.

|V(i − 1, γ, 0)| + p̄i ≤ di : Proof. As before, we denote ϕwB shortly as ϕ in the

elsif





i , V(i − 1, γ, 0) + p̄i }

max{r proof. We consider a reduction from the partition prob-





lem which, given a set of integers a1 , . . . , am that sums


else: − ∞


i ≥ 2 and 1 ≤ γ ≤ i and 1 ≤ α ≤ i:
up to 2A, asks whether there exists a subset S ⊆ [m]
such that i∈S ai = A. We construct the following in-
P




if V(i − 1, γ − 1, α − 1) + p̄i + p̂i > di or stance of problem maxδ∈∆Γ ϕ(δ). We have n = 3m + 1
V(i − 1, γ, α − 1) + p̄i > di :





 jobs, which we organize in triples {3k − 2, 3k − 1, 3k}
for k ∈ [m], plus the final job n = 3m + 1, and Γ = m.

max{V(i − 1, γ, α − 1) + p̄i ,






V(i − 1, γ − 1, α − 1) + p̄i + p̂i } Let M and N be integers large enough, to be defined






later. For each k ∈ [m], we define the weights as

1, γ − 1, α)| + p̄i + p̂i ≤ di and



elsif |V(i −
w3k−2 = ak , w3k−1 = 0, w3k = M, the processing times


1, γ, α)| + p̄i ≤ di :

|V(i −



p̄ = 0, and p̂3k−2 = kN + 2A − ak , p̂3k−1 = kN + 2A,


max{ri , V(i − 1, γ, α) + p̄i ,


p̂3k = 0, and the due dates d3k−2 = d3k = k(k+1)

2 N − 1 and


V(i − 1, γ − 1, α) + p̄i + p̂i }





 d3k−1 is non-restrictive (e.g., equal to the sum of all com-
1, γ − 1, α)| + p̄i + p̂i ≤ di

elsif |V(i −

ponents of p̂). For the last job, we define w3m+1 = M/2,




i , V(i − 1, γ − 1, α) + p̄i + p̂i }





 max{r p̄3m+1 = p̂3m+1 = 0, d3m+1 = m(m+1) N + (2m − 1)A − 1.
 2
elsif |V(i − 1, γ, α)| + p̄i ≤ di :

Finally, all released dates are equal to 0, namely, r = 0.





max{ri , V(i − 1, γ, α) + p̄i } We assume in what follows that M > 4A and N >






2mA. We observe that, because M > 4A, ϕ(δ) ≥ mM if


else: − ∞


Observe that in the last brace, it may happen for ex- and only if each job {3k | k ∈ [m] } is tardy. We claim
ample that V(i − 1, γ − 1, α − 1) + p̄i + p̂i > di and that (because N > 2mA) the latter happens if and only if
|V(i − 1, γ − 1, α)| + p̄i + p̂i ≤ di simultaneously, in
δ3k−2 + δ3k−1 = 1 for each k ∈ [m]. (4)
which case the maximum completion time is given by
V(i − 1, γ − 1, α − 1) + p̄i + p̂i and we fall into the We see first that for any δ ∈ ∆Γ that satisfies (4), t3k (δ) ≥
first case. Similarly, if V(i − 1, γ, α − 1) + p̄i > di and
2 N > d3k , so that each job in {3k | k ∈ [m] } is tardy.
k(k+1)
|V(i − 1, γ, α)| + p̄i ≤ di simultaneously, we fall again in Next, suppose (4) does not hold and let k′ ∈ [m] be the
the first case as the max is given by V(i−1, γ, α−1)+ p̄i . minimum value such that δ3k−2 + δ3k−1 , 1. If δ3k′ −2 +
δ3k′ −1 = 0, then t3k′ (δ) < k (k2+1) N and job 3k′ is not
′ ′
Finally, we obtain the maximum total numbers of
tardy jobs α as follows: tardy. If δ3k′ −2 + δ3k′ −1 = 2, then we prove that some
subsequent job is not tardy. We define k′′ > k′ as the
max {α | V(n, γ, α) , −∞ for some γ ∈ {0, . . . , Γ} } . minimum k ∈ [m] such that
Therefore, it is possible to implement a dynamic pro-
X
(δ3k−2 + δ3k−1 ) = k′′ .
gramming algorithm to maximize the total number of k∈[k′′ ]
tardy jobs with the time complexity of O(n2 Γ).
We explain next how to extend the above dynamic Observe that for each k ∈ [k′′ ] such that δ3k−2 + δ3k−1 =
programming algorithm to the case with time-warp, 2, there is some k < k′ ≤ k′′ such that δ3k′ −2 + δ3k′ −1 = 0.
3
Overall, this implies that tk′′ (δ) < k (k2 +1) N so the job is
′′ ′′
puted as F(1, γ, β) =
not tardy.
(r1 + p1 (γ) − d1 )+ + β · (r1 + p1 (γ)), if γ ∈ {0, 1}


There is now a natural bijection between sets S ⊆ 
,
[m] and vectors δ ∈ ∆Γ that satisfy (4). More precisely,

−∞
 otherwise
given such a vector δ, we define S (δ) ⊆ [m] as the set
that contains all indices k for which δ3k−2 = 1. We see where we use the notation pi (δ) = p̄i + δ p̂i . We obtain
that ϕ(δ) ≥ (m + 1/2)M only if job n is tardy, in addition a general recurrence for the remaining cases by relying
to the other m tardy jobs, which happens for all δ for on the recursive definition (2) and the definition τi (δ) =
(ti (δ) − di )+ . Denoting the concatenation of δ and δ′ as
which
δ||δ′ , we see that F(i, γ, β) =
m(m + 1) X
tn (δ) = N + 2mA − ai (5) max max τi−1 (δ) + (ti (δ||δ′ ) − di )+ + β · ti (δ||δ′ )
2 i∈S (δ)
δ′ ∈{0,1} δ∈∆i−1 ′
γ−δ

m(m + 1) = max max

> N + (2m − 1)A − 1. (6) δ ∈{0,1} δ∈∆i−1 ′
′
γ−δ
2  
max τi−1 (δ) + (β + 1)ti (δ||δ′ ) − di , τi−1 (δ) + β · ti (δ||δ′ )
The strict inequality (6) holds if only if 
X X = max max max τi−1 (δ) + (β + 1)ti−1 (δ) + (β + 1)pi (δ′ ) − di ,
δ ∈{0,1} δ∈∆i−1 ′
′
A− ai > −1 ⇔ ai ≤ A (7) γ−δ

i∈S (δ) i∈S (δ) τi−1 (δ) + (β + 1)ri + (β + 1)pi (δ′ ) − di ,

Focusing on δ that satisfy (4) and (7), we see that τi−1 (δ) + β · ti−1 (δ) + β · pi (δ′ ),

X τi−1 (δ) + β · ri + β · pi (δ′ )
ϕ(δ) = (m + 1/2)M + ai , 
i∈S (δ) = max max max {τi−1 (δ) + (β + 1)ti−1 (δ)} + (β + 1)pi (δ′ ) − di ,
δ ∈{0,1}
′
δ∈∆i−1 ′
γ−δ
which is maximized when i∈S (δ) ai = A. Therefore,
P
max {τi−1 (δ)} + (β + 1)ri + (β + 1)pi (δ′ ) − di ,
there exists δ such that ϕ(δ) = (m + 1/2)M + A if and δ∈∆i−1 ′
γ−δ
only if there exists a set S ⊆ [m] of integers that sums
max {τi−1 (δ) + β · ti−1 (δ)} + β · pi (δ′ ),
to A. δ∈∆i−1 ′
γ−δ

max {τi−1 (δ)} + β · ri + β · pi (δ′ )
δ∈∆i−1 ′
γ−δ

3. Tardiness with the basic model = max max F(i − 1, γ − δ′ , β + 1) + (β + 1)pi (δ′ ) − di ,
δ ∈{0,1}
′

F(i − 1, γ − δ′ , 0) + (β + 1)ri + (β + 1)pi (δ′ ) − di ,

We omit the superscript B of τ , B
τiB , B
and t through- F(i − 1, γ − δ′ , β) + β · pi (δ′ ),
out the section, and compute τ using a dynamic pro- 
F(i − 1, γ − δ′ , 0) + β · ri + β · pi (δ′ )
gramming algorithm described next. For each i ∈
[n] and γ ∈ [Γ] ∪ {0}, we denote by ∆iγ the pro-
Overall, all values of F(i, γ, β) can be computed in
jection of ∆γ on the components [i], formally ∆iγ = O(n2 Γ).
n o
δ ∈ {0, 1}i j∈[i] δ j ≤ γ , and for each i ∈ [n], we de-
P
We observe that the algorithm presented in this sec-
note by τi (δ) = j∈[i] τ j (δ) the sum over the tardiness
P
tion can be generalized to handle the weighted tardi-
for the first i jobs only. Observe that τi (δ) depends only ness. Given non-negative integer weights wi , the latter
on the first i components of δ, so we assume next that problem maximizes the function τw (δ) = i∈[n] wi τi (δ).
P
the argument of τi belongs to ∆iγ for some γ. In this case, the algorithm would consider the value-
Our dynamic programming algorithm is based on the function
value-function
F(i, γ, β) = max τiw (δ) + β · ti (δ),
δ∈∆iγ
F(i, γ, β) = max τ (δ) + β · ti (δ),
i
δ∈∆iγ
where τiw (δ) = j∈[i] w j τ j (δ) is the weighted sum of tar-
P
where β ∈ [n] ∪ {0}. Note that the optimal solution to dinesses for the first i jobs. One readily verifies that sim-
the problem maximizing τ over ∆Γ is given by F(n, Γ, 0). ilar reformulations hold, with the main difference that β
Furthermore, for i = 1, the value-function can be com-
P
now belongs to [ i wi ] ∪ {0}, yielding a total complex-
4
 Combining (10) for all i ∈ I and (11) for all i ∈ [i∗ ] \ I,
P
ity of O(nΓ i wi ). Hence, the algorithm is polynomi-
ally bounded only when the weights are constant, and we obtain that
the complexity of the problem is unknown when the as- X X
sumption does not hold. This idea can also be adapted ti∗ (δ) = r∗ + ( p̄i + δi p̂i ) − τi (δ).
to the lot-sizing problem as explained in the remark be- i∈[i∗ −1] i∈I\{i∗ }

low.
Then, τi∗ (δ) = ti∗ (δ) − di∗ , proving the result.
Remark 1. The above ideas can be extended to provide
polynomial-time algorithms for robust lot-sizing prob- Proposition 2 shows that the objective value of any
lems with budget uncertainty when considering scenario solution only depends on the last release date that gener-
generation algorithms [13, 14]. Stated shortly, the sep- ates a time warp. Hence, an effective approach to solve
aration problem of this case involves two main differ- the problem under non-restrictive intermediate release
ences with the problem considered so far. First, the com- dates is to probe for the last time warp index i∗ . From
pletion time of job i is replaced by the total demand at Proposition 2, for each candidate index i ∈ [n], the best
the end of period i, so ti for i ∈ {2, . . . , n} satisfies the solution for the case where i∗ = i is to set δ j = 1 for the
recurrence ti (δ) = ti−1 (δ) + p̄i + δi p̂i − xi , where xi is the min{i, Γ} largest values of p̂ j , for j ∈ [i], and δ j = 0 for
production during period i and t1 (δ) = p̄1 + δ1 p̂1 − x1 . the remaining components. This leads to the following
Notice the productions are assumed constant for the proposition:
separation problem, similarly to the order of the jobs Proposition 3. Problem (8) under assumption (9) can
that was assumed known in this paper (in both cases, be solved in O(n log Γ).
these are variables of the master problem). Second,
the cost at every period is given by the convex func- Proof. The algorithm performs one pass for i ∈ [n],
keeping track of P̄ = j∈[i] p̄ j and P̂ is equal to the sum
P
tion max(bi ti (δ), −si ti (δ)), where si and bi are given non-
negative parameters. Adapting the above ideas to this of the min{i, Γ} largest values of p̂ j . Updating P̄ takes
case leads to considering negative and positive values O(1) time but updating P̂ requires that the terms of the
for β, yielding a pseudo-polynomial time algorithm for sum be also maintained, which takes O(log Γ). The ob-
the problem, where the pseudo-polynomial factors in- jective value in each case is computed in O(1) time as
volve si and bi . In contrast, the pseudo-polymonial time r∗ + P̄ + P̂ − di following Proposition 2.
algorithm proposed by [13] depends on p̂i . In order to solve the complete problem, we use a re-
formulation more suited to the above results. Let σi
4. Tardiness with time-warp be an additional binary decision variable for i ∈ [n]
that models whether or not we apply the release date
Again we omit the superscript T W of τT W , τTi W , and
for job i. We adapt definition (3) and define t˜1 (δ, σ) =
tT W throughout the section, and study the optimization
r1 + p̄1 + δ1 p̂1 (observe t˜1 (δ, σ) does not depend on σ),
problem
and for each i ∈ {2, . . . , n}
max τ(δ). (8)
δ∈∆Γ 
min(di−1 , t˜i−1 (δ, σ)) + p̄i + δi p̂i if σi = 0

We first handle the case where intermediate release t˜i (δ, σ) = 

dates are not restrictive, formally ri + p̄i + δi p̂i
 if σi = 1.

ri ≤ r1 = r ∗ , ∀i = 2, . . . , n. (9) We adapt τi similarly and define

We have the following proposition for this case. τ̃i (δ, σ) = (t˜i (δ, σ) − di )+ ,
Proposition 2. Assume (9) holds, let δ ∈ ∆Γ and i∗ be for each i ∈ [n], as well as τ̃(δ, σ) = i∈[n] τ̃i (δ, σ). Con-
P
the largest i such that τi (δ) > 0. Then, τ(δ) = r∗ − di∗ + sider consequently the following optimization problem
i∈[i∗ ] ( p̄i + δi p̂i ).
P

Proof. Let I = {i ∈ [n] | τi (δ) > 0 }. Note that, for all max τ̃(δ, σ). (12)
δ∈∆Γ ,σ∈{0,1}n
i ∈ I \ {i∗ }, we have
Proposition 4. Let (δ∗ , σ∗ ) be an optimal solution
ti (δ) = ti−1 (δ) + p̄i + δi p̂i − τi (δ). (10) of (12). Then, δ∗ is an optimal solution to (8) and
τ(δ∗ ) = τ̃(δ∗ , σ∗ ).
Moreover, for all i ∈ [i∗ ] \ I, we have
Proof. Let (δ∗ , σ∗ ) be an optimal solution of (12). We
ti (δ) = ti−1 (δ) + p̄i + δi p̂i . (11) define σ̄ ∈ {0, 1}n by fixing σ̄i = 1 if ti (δ∗ ) ≤ ri and
5
0 otherwise. Note that (δ∗ , σ̄) is feasible for (12) and 5. Numerical illustration
τ̃(δ∗ , σ̄) = τ(δ∗ ). Hence,
We conducted experiments to evaluate our proposed
τ̃(δ∗ , σ∗ ) ≥ τ̃(δ∗ , σ̄) = τ(δ∗ ). (13) algorithm for optimizing τB . Specifically, we selected a
subset of instances proposed by Dumas et al. [15] for the
Moreover, since σ̄i = 1 if and only if t˜i (δ∗ , σ̄) = t˜i (δ∗ ) ≤ traveling salesman problem with time windows, adapted
ri , t˜i (δ∗ , σ̄) ≥ t˜i (δ∗ , σ) for any σ ∈ {0, 1}n . As a result, to our case. The instances varied in length, with n rang-
τ̃(δ∗ , σ̄) ≥ τ̃(δ∗ , σ∗ ), and therefore, τ(δ∗ ) ≥ τ̃(δ∗ , σ∗ ). ing in {20, 40, 60, 80, 100, 150} (140 instances in total).
Together with (13), we obtain that τ(δ∗ ) = τ̃(δ∗ , σ∗ ). For this problem, p̄i represents the nominal traveled dis-
Finally, assume δ∗ is not optimal for (8). Then, there tance, which is determined by computing the Euclidean
exists δ̄ such that τ(δ̄) > τ(δ∗ ), and repeating the above distance to the subsequent job i + 1, as well as to the
procedure, we construct σ̄ such that τ̃(δ̄, σ̄) = τ(δ̄) > first job when considering the last job in the sequence.
τ(δ∗ ) = τ̃(δ∗ , σ∗ ). We considered Γ equal to {10%, 20%, 30%} of n and the
deviation p̂i equal to {10%, 50%, 100%} of p̄i . All the
The algorithm we propose next for (12) relies on the resulting values are rounded down. For each combi-
following observation. On the one hand, setting σi to nation, we generated ten random sequences and solved
0 relaxes the release date of job i, in line with (9). On them via (i) the dynamic programming algorithm of
the other hand, setting σi to 1 splits the problem into the Section 3 and (ii) a straightforward MILP formulation.
one involving jobs in [i−1], and the subsequent one with Both methods were implemented in Julia 1.9, where
jobs [n] \ [i − 1]. For the sake of deriving a dynamic pro- the MILP model uses JuMP v1.18.1 [16] with CPLEX
gramming algorithm, let us denote by T (i, γ) the maxi- 22.1.1. Moreover, all experiments were executed on a
mum total tardiness obtained for jobs in [i − 1] setting at single thread of an Apple M2 CPU with 16 GB of RAM.
most γ values of δ to 1 among the indices of [i]; in par- The implementation code and instances are publicly
ticular, T (n+1, Γ) is equal to the optimal solution cost of available at https://github.com/igormalheiros/
problem (12). Let also T u (i, j, γ) be the maximum total worst-case-tardiness-budget-uncertainty.
tardiness obtained for the jobs in {i, . . . , j − 1}, using ri−1 Figure 1 shows the geometric averages of the ratios
for the release date of job i − 1, ignoring release dates between the CPU times of the dynamic programming
for jobs in {i + 1, . . . , j − 1}, and setting at most γ values approach and the CPU times of the MILP formulation.
of δ to 1 among the indices of {i, . . . , j − 1}. Following
the above discussion on the value of σi , T (i, γ) satisfies Γ = 0.10
the following recursion: 2 Γ = 0.20
Γ = 0.30

0,

 if i = 1
runtime ratio

1.5
T (i, γ) =  ,


 max T ( j, θ) + T ( j, i, γ − θ) if i > 1
 j∈[i],θ∈[γ]∪{0}
u

1
where we assume that T u (i, i, γ) = 0 for i ∈ [n], and,
γ = 0, . . . , Γ. The maximization over j in the recursion 0.5
seeks the optimal index j ∈ [i] such that σ j = 1 and
σk = 0 for k ∈ { j + 1, . . . , i}.
0
20 40 60 80 100 120 140
Proposition 5. T (n + 1, Γ) can be computed in O(n Γ ). 2 2
number of jobs

Proof. From the procedure proposed in the proof of Figure 1: Geometric averages of the solution runtimes obtained using
Proposition 3, T u (i, j, γ) can be computed in O(n log Γ) DP, divided by those of the MILP formulation.
for a fixed i, and γ, and j = i, . . . , n. Thus, comput-
ing the whole table of T u takes O(n2 Γ log Γ). Then, it Note that, as the number of jobs and the budget pa-
remains to fill the O(nΓ) values of T , each one taking rameter increase, the runtime ratio increases. For se-
O(nΓ) time. This gives the stated complexity. quences with fewer than 100 jobs, the dynamic pro-
gramming was between 1.1 and 100 times faster than
We remark that, unlike the algorithms presented in MILP model. For the instances with 150 jobs, the for-
the previous sections, it is not clear how to extend the mer was 1.25 times faster than the latter when the budget
algorithm of this section to the weighted counterpart of is 10%, but the latter was 1.5 to 2.3 times faster than the
the problem. former for budgets of 20% and 30% respectively. This
6
trend suggests that the MILP formulation performs bet- tics 21 (2015) 329–358. URL: https://doi.org/10.1007/
ter for larger sequences. s10732-014-9273-y. doi:10.1007/S10732-014-9273-Y.
[11] Y. Nagata, O. Bräysy, W. Dullaert, A penalty-based edge as-
Nonetheless, the proposed dynamic programming sembly memetic algorithm for the vehicle routing problem with
approach could enhance parallel-machine/routing- time windows, Comput. Oper. Res. 37 (2010) 724–737. URL:
associated problems, which typically involve sequences https://doi.org/10.1016/j.cor.2009.06.022. doi:10.
with up to 80 jobs/customers per machine/route in their 1016/J.COR.2009.06.022.
[12] T. Vidal, T. G. Crainic, M. Gendreau, C. Prins, A hybrid genetic
best-known solutions for classical instances [17, 18], algorithm with adaptive diversity management for a large class
often much less than this. Therefore, the results of vehicle routing problems with time-windows, Comput. Oper.
achieved by the dynamic programming scheme indicate Res. 40 (2013) 475–489. URL: https://doi.org/10.1016/
that this method is preferable over the MILP, particu- j.cor.2012.07.018. doi:10.1016/J.COR.2012.07.018.
[13] A. Agra, M. C. Santos, D. Nace, M. Poss, A dynamic pro-
larly when used within local search algorithms where gramming approach for a class of robust optimization problems,
numerous evaluations are performed on sequences of SIAM J. Optim. 26 (2016) 1799–1823. URL: https://doi.
jobs/customers. org/10.1137/15M1007070. doi:10.1137/15M1007070.
[14] D. Bienstock, N. Özbay, Computing robust basestock lev-
els, Discret. Optim. 5 (2008) 389–414. URL: https://
doi.org/10.1016/j.disopt.2006.12.002. doi:10.1016/
References
J.DISOPT.2006.12.002.
[15] Y. Dumas, J. Desrosiers, É. Gélinas, M. M. Solomon, An
[1] A. Agra, M. Christiansen, R. M. V. Figueiredo, L. M. Hvattum,
optimal algorithm for the traveling salesman problem with
M. Poss, C. Requejo, The robust vehicle routing problem with
time windows, Oper. Res. 43 (1995) 367–371. URL: https:
time windows, Comput. Oper. Res. 40 (2013) 856–866. URL:
//doi.org/10.1287/opre.43.2.367. doi:10.1287/OPRE.
https://doi.org/10.1016/j.cor.2012.10.002. doi:10.
43.2.367.
1016/J.COR.2012.10.002.
[16] M. Lubin, O. Dowson, J. Dias Garcia, J. Huchette, B. Legat,
[2] P. A. Munari, A. Moreno, J. D. L. Vega, D. J. Alem, J. Gondzio,
J. P. Vielma, JuMP 1.0: Recent improvements to a
R. Morabito, The robust vehicle routing problem with time win-
modeling language for mathematical optimization, Math-
dows: Compact formulation and branch-price-and-cut method,
ematical Programming Computation (2023). doi:10.1007/
Transp. Sci. 53 (2019) 1043–1066. URL: https://doi.
s12532-023-00239-3.
org/10.1287/trsc.2018.0886. doi:10.1287/TRSC.2018.
[17] S. Tanaka, M. Araki, A branch-and-bound algorithm with
0886.
lagrangian relaxation to minimize total tardiness on iden-
[3] M. Bold, M. Goerigk, A compact reformulation of the two-stage
tical parallel machines, International Journal of Produc-
robust resource-constrained project scheduling problem, Com-
tion Economics 113 (2008) 446–458. URL: http://dx.
put. Oper. Res. 130 (2021) 105232. URL: https://doi.org/
doi.org/10.1016/j.ijpe.2007.10.006. doi:10.1016/j.
10.1016/j.cor.2021.105232. doi:10.1016/J.COR.2021.
ijpe.2007.10.006.
105232.
[18] J. Homberger, H. Gehring, Two evolutionary metaheuris-
[4] M. Silva, M. Poss, N. Maculan, Solution algorithms for min-
tics for the vehicle routing problem with time windows, IN-
imizing the total tardiness with budgeted processing time un-
FOR: Information Systems and Operational Research 37 (1999)
certainty, Eur. J. Oper. Res. 283 (2020) 70–82. URL: https:
297–318. URL: http://dx.doi.org/10.1080/03155986.
//doi.org/10.1016/j.ejor.2019.10.037. doi:10.1016/
1999.11732386. doi:10.1080/03155986.1999.11732386.
J.EJOR.2019.10.037.
[5] B. Tadayon, J. C. Smith, Algorithms and complexity analy-
sis for robust single-machine scheduling problems, J. Sched.
18 (2015) 575–592. URL: https://doi.org/10.1007/
s10951-015-0418-0. doi:10.1007/S10951-015-0418-0.
[6] B. Zeng, L. Zhao, Solving two-stage robust optimization prob-
lems using a column-and-constraint generation method, Oper.
Res. Lett. 41 (2013) 457–461. URL: https://doi.org/10.
1016/j.orl.2013.05.003. doi:10.1016/J.ORL.2013.05.
003.
[7] B. C. Shelbourne, M. Battarra, C. N. Potts, The vehicle rout-
ing problem with release and due dates, INFORMS J. Com-
put. 29 (2017) 705–723. URL: https://doi.org/10.1287/
ijoc.2017.0756. doi:10.1287/IJOC.2017.0756.
[8] W. Yang, L. Ke, D. Z. Wang, J. S. L. Lam, A branch-
price-and-cut algorithm for the vehicle routing problem with re-
lease and due dates, Transportation Research Part E: Logistics
and Transportation Review 145 (2021) 102167. URL: http://
dx.doi.org/10.1016/j.tre.2020.102167. doi:10.1016/
j.tre.2020.102167.
[9] M. Bougeret, A. A. Pessoa, M. Poss, Single machine robust
scheduling with budgeted uncertainty, Oper. Res. Lett. 51 (2023)
137–141. URL: https://doi.org/10.1016/j.orl.2023.
01.007. doi:10.1016/J.ORL.2023.01.007.
[10] T. Vidal, T. G. Crainic, M. Gendreau, C. Prins, Time-
window relaxations in vehicle routing heuristics, J. Heuris-