J Sched
DOI 10.1007/s10951-015-0426-0
Scheduling with returnable containers
Arne Mensendiek1
© Springer Science+Business Media New York 2015
Abstract Many supply chains use returnable packaging
such as plastic and metal containers, folding boxes, racks,
and trays to transport components from suppliers to buyers.
This study investigates the scheduling problem of a supplier
that produces jobs for several buyers where the jobs for each
buyer have to be delivered in that buyer’s returnable contain-
ers. Empty containers are provided by the buyers at certain
release dates. The supplier can process a job when no ade-
quate empty containers are available, but then incurs extra
handling costs to pack the job into auxiliary packaging and
repack it later. This study extends single machine scheduling
with weighted earliness and tardiness penalties and batching
by including returnable containers and repacking penalties.
A mathematical programming formulation and a two-stage
heuristic for this previously unstudied NP-hard scheduling
problem are proposed and evaluated in a numerical study.
Keywords Returnable containers · Single machine
scheduling · Earliness and tardiness · Batching · Family
setups · Heuristic algorithms
1 Motivation
Many supply chains use returnable containers to transport
parts from suppliers to buyers. Returnable containers offer
many potential benefits such as packaging and process stan-
dardization, lower risk of parts damage, and better utilization
B Arne Mensendiek
arne.mensendiek@googlemail.com;
amensendiek@wiwi.uni-bielefeld.de
1 their buyers, e.g., downstream manufacturers.
Department of Business Administration & Economics,
Bielefeld University, Universitätsstraße 25, 33615 Bielefeld,
Germany
of storage space. On the other hand, the use of such containers
requires costly returns of empties and creates various man-
agerial and planning issues. In particular, the availability of
empty containers places major constraints on a supplier’s pro-
duction scheduling decisions. Before we formally state this
scheduling problem in the next section, we give an overview
of the problem context.
Reusable packaging is particularly common in the auto-
motive industry (Hofmann and Bachmann 2006). For exam-
ple, carmaker Shanghai Volkswagen’s plant in Ningbo, China
uses returnable packaging for more than 90% of a car’s parts
(Coia 2014), and automotive supplier Johnson Controls plans
to increase the use of returnable packaging in North Amer-
ica to more than 80% (Coia 2013). Volkswagen uses about
2500 types of returnable packaging (Lackner and Zsifkovits
2006), such as plastic and metal containers, folding boxes,
racks, and trays. For convenience, we refer to all these types
of returnable packaging as returnable containers. Many con-
tainers are specifically designed for particular parts such as
bumpers, door panels, or airbags. On the other hand, there
are also several types of standardized containers, such as
small plastic boxes that are designed in line with the stan-
dards of the German Association of the Automotive Industry.
Returnable containers are used in many other industries as
well. For example, returnable plastic totes and roller cages
are used for product distribution in the grocery and dairy
industries (Kärkkäinen et al. 2004). The use of returnable
bottles is common in the beverage industry, and it requires an
adequate reverse logistics system (Del Castillo and Cochran
1996). While the circulation of returnable bottles includes
the final customer, in this research we focus on container
loops between firms, namely manufacturing suppliers and
The containers may be owned and managed by the sup-
pliers, by the buyers, or by a third-party logistics provider.
123

Kroon and Vrijens (1995) study the optimal design of a logis-
tics provider’s returnable container system. Nevertheless, in
automotive supply chains it is often the buyers that control
the downstream container loops. That is, carmakers such as
Chrysler and Volkswagen own and manage the containers
that are exchanged with tier one suppliers, while tier one
suppliers such as Bosch own and manage the containers that
are exchanged with tier two suppliers (Yildiz et al. 2010).
Whenever a buyer owns the containers, it usually restricts the
supplier’s use of them. For instance, Chrysler does not permit
its suppliers to use Chrysler containers for storage of work
in progress or raw materials (Chrysler LLC 2009). Buyer-
owned containers cannot be exchanged between different
buyers. Each buyer decides when and how many empties are
returned to the supplier. Typically, the buyer will only provide
enough containers to ship its next few orders. For example,
Bosch bases the number of empties it returns to its suppliers
on the order volume and allows for some additional con-
tainers to hold three days’ worth of inventory (Robert Bosch
GmbH 2007). The Navistar Engine Group, a manufacturer
of engines for commercial vehicles, also adapts its returns of
empties to the order volume (Yates and Wyant 2012). Yildiz
et al. (2010) study the vehicle routing problem that arises at
a plant of Bosch in this context. In particular, their purpose is
to match inbound parts deliveries with returns of empties to
the suppliers. Once the use of returnable containers has been
established, buyers often impose contractual fines or threaten
to reject shipments if a supplier uses other packaging. Con-
sequently, suppliers are required to ship orders in returnable
containers, but the release dates and the number of empties
are determined by the buyers and are hence exogenously
given for the supplier’s scheduling and batching decisions.
A supplier usually requires several containers to ship an
order since each container can only hold a certain quantity of
the product. In this paper, we consider a production process
where finished product is (by approximation) continuously
retrieved from the machine and packed into containers. To
illustrate, consider processing an order of 200 steering wheels
on an injection molding machine that produces one wheel at
a time which is then retrieved so that the next wheel can be
produced. Obviously, the supplier needs one empty container
when starting to process the order. The container can hold a
certain number of steering wheels and once it is full, it is
moved to an outbound storage area and replaced by another
empty container, and so on. Obviously, it is desirable to pack
the product directly into the returnable containers. However,
when no empty returnable containers are available, the sup-
plier can pack the product into auxiliary packaging such as
cardboard boxes before moving it into storage. In that case,
the product needs to be repacked once the correct empties
arrive and before the order can be shipped. Consequently,
processing a job when no returnable containers are available
causes additional handling costs for the supplier (Schmölzer
123
J Sched
and Schöfer 2005; Robert Bosch GmbH 2007). The avail-
ability of empties can thus have an impact on the supplier’s
scheduling and batching decisions. For example, suppose
that a supplier has received orders with identical process-
ing times and due dates from two buyers. If both buyers have
already provided empties, then the supplier is indifferent to
the processing sequence of the orders. Yet if empties are
available for only one of the orders, then it is preferable to
start with that order since the empty containers for the other
order may arrive in the meantime. As a different example,
the supplier may choose to batch orders for one buyer to
save setup costs. However, batching is less favorable if there
are not enough empty containers to pack the whole batch.
The remainder of this paper is structured as follows. In
the next section, we state the supplier’s scheduling problem
more formally and review the related scheduling literature.
In Sect. 3, we discuss the computational complexity of the
problem and provide a mixed-integer programming formu-
lation. In Sect. 4 and 5, we propose and evaluate a two-stage
tailormade heuristic. Sect. 6 concludes.
2 Problem statement and literature review
We study the scheduling problem of a supplier who produces
parts for l = 1, . . . , L different buyers. Each buyer places
several orders and each order is considered one job for the
supplier. Each job j = 1, . . . , J has an associated integer
processing time p j and a due date d j . All jobs are processed
non-preemptively on a single machine that can process one
job at a time and is ready at time zero. Jobs for one buyer
are considered as one job family. A batch setup with family-
independent setup time s is required for the first job that
is processed on the machine and whenever two jobs from
different families are processed one after another. A subset
of jobs from one family that is processed consecutively is
called one batch. The supplier incurs a setup cost γ per unit
of setup time.
All jobs have to be delivered in returnable containers. Each
buyer uses a different type of returnable container, and con-
tainers from different buyers cannot be interchanged. Each
buyer organizes several returns of empty containers to the
supplier. We refer to these returns of empties as releases
k = 1, . . . , K . At the release date rk , the supplier receives ck
empty containers from one of the buyers. The supplier has
no initial inventory of returnable containers, but an unlimited
inventory of auxiliary packaging.
Empty containers are required during a job’s process-
ing to pack the parts that are produced. For simplicity, we
assume that a job with integer processing time p j requires
the same integer number of empty containers, that is to say,
one container is required per unit of processing time. The
first container is required at the very beginning of the job’s
J Sched
processing, i.e., at C j − p j where C j denotes the job’s com-
pletion time. The second empty container is required after one
unit of processing time (when the first container is full), and
so on. Whenever no empty returnable container is available,
by using auxiliary containers the supplier can still process
and pack the job so that the machine is not blocked. How-
ever, a job cannot be delivered before it is due, its processing
is completed, and it is (re-)packed into the correct contain-
ers. D j denotes the time when job j is delivered. Due to the
aforementioned additional handling costs, the supplier incurs
a penalty δ per missing returnable container. Additional time
for repacking is not considered.
Each buyer provides exactly the number of empty con-
tainers the supplier needs to ship all the buyer’s orders; that
is, for each job family the number of containers equals the
total processing time. Moreover, in accordance with industry
practice we assume that the buyers provide empty containers
so early that the supplier never faces a shortage of empties
as long as it processes all jobs such that they are completed
at their due dates or later.
In addition to the setup cost γ and the repacking cost δ,
the supplier incurs an earliness penalty α per unit of time if a
job is completed before its delivery, and a tardiness penalty
β per unit of time if a job is delivered after its due date. The
earliness penalty accounts for inventory holding costs and
the tardiness penalty includes costs for express delivery or
contractual fines. As these costs tend to be higher for larger
jobs, earliness and tardiness are weighted with job processing
times. Earliness is defined as Ẽ j = (D j − C j )+ and tardi-
ness as T̃ j = (D j − d j )+ where D j denotes the time when
job j is delivered. As a job may remain in inventory after its
completion because it has to wait for containers, the defin-
itions of Ẽ j and T̃ j are slightly different from the standard
definitions E j = (d j − C j )+ and T j = (C j − d j )+ .
In summary, the supplier’s problem is to determine a
schedule and an assignment of containers to jobs that min-
imize the sum of earliness, tardiness, setup, and repacking
 job processing times, 1|| j p j (C j − d j )+ , is NP-hard in
costs. We can state this problem as 1|sl = s, RC|α j p j Ẽ j

+β j p j T̃ j +γ ST +δ R PC K where RC denotes the pres-
ence of returnable containers, ST the total setup time, and
R PC K the number of repacked containers. Henceforth, we
refer to this problem as scheduling with returnable containers
(SRC).
Apart from the restricted availability of returnable con-
tainers and the repacking penalty, SRC is a single machine
earliness-tardiness scheduling problem with batching.
Scheduling with batching and earliness-tardiness scheduling
have both been studied intensively. Reviews of the liter-
ature on scheduling with setup considerations have been
provided by Potts and Kovalyov (2000) and Allahverdi et al.
(1999, 2008). Baker and Scudder (1990) discuss the lit-
erature on problems with earliness and tardiness penalties
until 1990. As the latter problems have a non-regular per-
formance measure, that is, an objective function that is not
non-decreasing in job completion times, it is often necessary
to consider inserting idle time (Garey et al. 1988). Among
the authors who combine both earliness-tardiness schedul-
ing and batching, (Azizoglu and Webster 1997) address the
weighted earliness and tardiness problem with sequence-
independent batch setup times anda common due date,
denoted as 1|sl , d j = d| j w j E j + j w j T j . Sourd (2005)
formulates a time-indexed assignment model to minimize
punctuality costs and sequence-dependent setup costs. He
proposes a branch-and-bound algorithm for problems with
up to 20 jobs and a local search method based on pairwise
interchange of jobs. Sourd (2006) compares the results of
this heuristic with dynasearch, a local search procedure for
large neighborhoods. While dynasearch requires more com-
putational time, it can improve the solutions for instances
with 30 to 100 jobs. Schaller (2007) develops a branch-

and-bound algorithm for the problem 1|sl | j T j that is
enhanced
 by Schaller
 and Gupta (2008) to solve the problem
1|sl | j E j + j T j . These authors also propose an effec-
tive two-stage heuristic with complexity bounded by O(J 3 )
which we use to develop the solution approach for SRC in
Sect. 4.
3 Optimal solution by mathematical programming
In this section, we first show that SRC is NP-hard in the strong
sense. While this suggests that it may often be hard to obtain
optimal solutions, we provide a mathematical programming
formulation to solve problems with up to 15 jobs to optimal-
ity. In Sect. 5.2, these solutions are used as benchmarks to
evaluate the performance of the heuristic.
Arkin and Roundy (1988) show that the problem of mini-
mizing total weighted tardiness where the weights equal the

the ordinary sense. As SRC is more general, it is also at least
NP-hard in the ordinary sense. However, it can be shown
that SRC is even NP-hard in the strong sense by analyzing

the special case 1|RC| j p j (D j −d j )+ + δ R PC K which
does not incorporate earliness penalties and setups.

Proposition 1 The special case 1|RC| j p j (D j − d j )+ +
δ R PC K is NP-hard in the strong sense.
Proof We prove the strong NP-completeness of the corre-
sponding decision problem by transforming any instance
of the 3-Partition Problem (3PP), a known strongly NP-
complete problem (Garey and Johnson 1979) into an instance
of the above special case. 3PP can be stated as follows: given
a set X = {1,. . . , 3m} and a set A of integers A1 , . . . , A3m
with m B = j∈X A j and B4 < A j < B2 ∀ j ∈ X , can X be
123
 J Sched

B B dj Integer due date of job j

pj Integer processing time of job j
j=1 j=2 ... j=m
rk Integer release date of container release k
ck Integer number of empty containers that are
r1 d1 r2 d2 rm dm released in release k
=B+1 = mB + m
a jl A binary parameter; a jl = 1 if job j
Fig. 1 Idle time after scheduling jobs j = 1, . . . , m belongs to family l
bkl A binary parameter; bkl = 1 if release k
 m disjoint subsets X 1 , . . . , X m such that, for
partitioned into belongs to family l
1 ≤ i ≤ m, j∈X i A j = B? s Setup time
Construct J = 4m jobs and L = 2 job families with α The coefficient of earliness cost
β The coefficient of tardiness cost
pj = 1 ∀ j = 1, . . . , m γ Setup cost per unit of setup time
dj = j B + j ∀ j = 1, . . . , m δ Cost of repacking one container
q A sufficiently large number
p j = A j−m ∀ j = m + 1, . . . , 4m
dj = mB + m ∀ j = m + 1, . . . , 4m

where jobs j = 1, . . . , m belong to the first job family and 3.2 Variables
j = m + 1, . . . , 4m to the second family.
In addition, construct K = m + 1 container releases. For xi j A binary variable; xi j = 1 if job i precedes
the first family, there are m releases with job j on the machine
yj A binary variable; y j = 1 if job j is the first
ck = 1 ∀ k = 1, . . . , m job processed on the machine
rk = (k − 1) + k B ∀ k = 1, . . . , m Cj Completion time of job j’s processing
Dj Delivery time of job j
and for the second family there is one release with rm+1 = 0 Ẽ j Earliness of job j
and cm+1 = m B. Finally, let δ = 1 and Z = 0 where Z T̃ j Tardiness of job j
denotes the threshold value of the objective function. The u jk An integer variable; number of containers
question is if there are a schedule and a container assignment of release k assigned to job j that need to

such that j p j (D j − d j )+ + δ R PC K ≤ Z . be repacked
Obviously, jobs j = 1, . . . , m have to be completed at v jk An integer variable; number of containers
their due dates to avoid tardiness and repacking penalties. of release k assigned to j that potentially
The resulting schedule is depicted in Fig. 1 and includes need to be repacked
an idle time of B periods before the processing of each job w jk An integer variable; number of containers
j = 1, . . . , m. of release k assigned to job j
To avoid tardiness, jobs j = m + 1, . . . , 4m have to be z jk A binary variable; z jk = 1 if w jk > 0
processed exactly during the idle periods and hence 3PP has
a “yes” answer iff the special case of SRC has a “yes” answer.


3.3 Problem statement
In the mathematical programming formulation, binary
variables represent the job sequence and integer variables
the assignment of empty containers to jobs. ⎛

J 
J

3.1 Parameters min ⎝α p j Ẽ j + β p j T̃ j

j=1 j=1
⎛ ⎞
i, j Indices for jobs (i, j = 1, . . . , J, J + 1), 
J 
J 
L
where J + 1 is an artificial last job +γ s ⎝ (ail − a jl )2 a jl xi j + 1⎠
k Index for empty container releases (k = i=1 j=1, j=i l=1
⎞
1, . . . , K )

J 
K
l Index for job families (l = 1, . . . , L), +δ u jk ⎠ (1)
equivalent to distinct types of containers j=1 k=1

123
J Sched

subject to


J
yj = 1 (2) j
j=1
J +1

x ji = 1 ∀ j = 1, . . . , J Cj − pj rk rk = Cj
i=1,i= j
(3)
Fig. 2 Container assignment and repacking

J
yj + xi j = 1 ∀ j = 1, . . . , J
i=1,i= j The objective (1) is to minimize the sum of weighted ear-
(4) liness
J  and tardiness,
 L setup, and 2repacking costs. The term
J
Cj ≥ s + pj ∀ j = 1, . . . , J i=1 j=1, j=i l=1 (ail −a jl ) a jl x i j +1 defines the num-
ber of setups where “+1” accounts for the initial setup.
(5)
Constraints (2)–(6) describe the well-known single

L
machine scheduling problem with setups and make sure that
C j ≥ Ci + p j + s (ail − a jl )2 a jl xi j − q(1 − xi j )
only one job is processed first, each job except the last job
l=1
has a successor, each job except the first job has a predeces-
∀ i, j = 1, . . . , J ; i = j (6) sor, the first job can only be completed after an initial setup
and subsequent processing, and no job can be started before
its predecessor’s completion time plus a setup time where
Dj ≥ dj ∀ j = 1, . . . , J (7) necessary.
Dj ≥ Cj ∀ j = 1, . . . , J (8) Constraints (7)–(9) demand that a job cannot be delivered
before it is due, its processing is completed, and all contain-
D j ≥ z jk rk ∀ j = 1, . . . , J ; k = 1, . . . , K (9)
ers for the job are released. If a job is completed before its
Ẽ j ≥ D j − C j ∀ j = 1, . . . , J (10) delivery, it is early (10) and if it is delivered after its due date,
Ẽ j ≥ 0 ∀ j = 1, . . . , J (11) it is tardy (12).
Constraints (16) and (17) make sure that each job is
T̃ j ≥ D j − d j ∀ j = 1, . . . , J (12) assigned the number of empty containers it requires and
T̃ j ≥ 0 ∀ j = 1, . . . , J (13) that no more containers are assigned than are released. Con-
xi j ∈ {0, 1} ∀ i, j = 1, . . . , J + 1; i = j (14) straints (18) and (19) define if any container from release k
is assigned to job j.
y j ∈ {0, 1} ∀ j = 1, . . . , J (15)
Constraints (20) to (22) define the number of contain-

K
ers that need to be repacked. Recall that by assumption one
w jk bkl = p j a jl ∀ j = 1, . . . , J ; l = 1, . . . , L (16) container is required at the beginning of the job’s process-
k=1
ing, one after one unit of processing time, and so on. There

J
is no repacking if the empties are released before a job
w jk ≤ ck ∀ k = 1, . . . , K (17)
is processed, and all w jk empties from release k that are
j=1
assigned to job j need to be repacked if release k occurs after
q · z jk ≥ w jk ∀ j = 1, . . . , J ; k = 1, . . . , K (18) processing. As illustrated by Fig. 2, the amount of repacking
z jk ∈ {0, 1} ∀ j = 1, . . . , J ; k = 1, . . . , K (19) is harder to determine when empty containers arrive during
the job’s processing.
Here, we have w jk = w jk = 2 and it is optimal to use
 one of the containers from release k for the part of the job
v jk ≥ rk z jk + w jk − C j that is processed after rk so that only three containers need
k :rk ≤rk ≤rk to be repacked. On the other hand, it is also possible (though
∀ j = 1, . . . , J ; k = 1, . . . , K ; k : rk ≤ rk (20) not optimal) to use the containers from release k for the first
part of job j and repack all four containers. The assignment
variables contain no information on how the containers are
assigned within the job, and hence an additional consider-
v jk ≥ 0 ∀ j = 1, . . . , J ; k = 1, . . . , K (21)
ation is necessary to identify how many containers need to
u jk = min{v jk , w jk } ∀ j = 1, . . . , J ; k = 1, . . . , K (22) be repacked. The idea behind constraint (20) is to construct

123

wjk = 2
wjk = 2
vjk ≥ rk + 2 − Cj
vjk ≥ rk + 2 + 2 − Cj
j
rk rk = Cj
Fig. 3 Hypothetical range of coverage of the containers
a hypothetical scenario without repacking and compare this
with the job’s actual completion time. To illustrate this idea,
first consider release k . If the containers from release k are
not to be repacked, then the completion time of job j should
be no less than rk + w jk = rk + 2. Yet the job’s actual
completion time is only C j = rk + 1, so it is clear that one
empty container arrives too late and needs to be repacked.
As depicted in Fig. 3, a similar argument holds for release k.
Constraints (20) and (21) can lead to results where v jk >
w jk . For example, in Fig. 3 we have v jk ≥ 3, but only two
containers from release k are assigned to job j and thus at
most these two containers have to be repacked. Constraint
(22) (or similar linearized constraints) limits v jk accordingly.
4 Heuristic solution
The numerical results in Sect. 5 indicate that the mathemat-
ical programming formulation can be used to solve small
instances of SRC while larger instances can often not be
solved in a reasonable computational time. Therefore, we
now propose a heuristic solution approach for SRC that we
refer to as SRC-H.
A solution of an SRC instance consists of completion
times for all jobs and an assignment of empty containers
to jobs. Our heuristic is a two-stage approach, that is, it first
constructs an initial schedule and container assignment and
then tries to improve this initial solution. In the following,
we first describe the construction of the initial schedule. We
then show that the container assignment problem is not triv-
ial even when the schedule is given and develop a heuristic
for this subproblem. Afterwards, several improvement pro-
cedures based on local search are presented.
4.1 Initial schedule
The initial schedule is calculated by an Insertion Algo-
rithm similar to that proposed by Schaller and Gupta (2008).
Throughout the following, we assume without loss of gener-
ality that jobs are indexed in non-decreasing order of their due
dates and container releases are indexed in non-decreasing
order of their release dates.
123
J Sched
4.1.1 Insertion Algorithm
The algorithm selects the two jobs with the lowest indices and
creates both possible sequences. As the objective criterion
is non-regular, insertion of idle time needs to be consid-
ered. SRC-H includes a Timetabling Algorithm adapted from
Garey et al. (1988) which is modified to account for weighted
asymmetric earliness and tardiness penalties. We execute the
Timetabling Algorithm for both initial sequences, calculate
the sum of earliness, tardiness, and setup costs and accept
the schedule with the lower sum of costs.
For j ≥ 3, let j denote the index of the first job that
has not been scheduled, so that the partial sequence already
contains the jobs 1, . . . , j −1. Job j is inserted into each pos-
sible position of that sequence, idle time is inserted using the
Timetabling Algorithm, and the sum of earliness, tardiness,
and setup costs is calculated. The schedule with the lowest
cost is selected, and the algorithm proceeds to job j + 1 until
all jobs are scheduled.
4.2 Container assignment for a given schedule
Recall from Fig. 2 that the decision to assign w jk empties
from release k to job j does not state whether the empties need
to be repacked whenever the release occurs during process-
ing. We introduce the concept of job fragments to resolve
this ambiguity. We then show that it is easy to assign con-
tainers to job fragments when the assignment to jobs is given.
Yet the latter problem is NP-hard and hence we solve it by a
Container Assignment Heuristic.
4.2.1 Fragment Definition
In order to determine whether containers that are assigned
to a job need to be repacked, we decompose jobs whose
processing overlaps a release date into job fragments that do
not overlap this date.
In the example illustrated in Fig. 4, job j is split into two
job fragments with fragment completion times C̃1 = rk and
C̃2 = C j , due dates d̃1 = d̃2 = d j and processing times
wjk = pj
j
f =1 f =2
C̃1 = rk C̃2 = Cj
Fig. 4 Decomposition of job j into job fragments
J Sched

p
p̃1 = p̃2 = 2j . The assignment variable w̃ f k denotes if on the repacking penalties as well as the earliness and tardi-
empty containers from release k are assigned to fragment f . ness penalties. In particular, a job may incur due-date-related
Since the first fragment is processed before rk , the containers penalties if it has to wait for empty containers before it can
that are assigned to this fragment need to be repacked, while be delivered.
those assigned to the second fragment need not be repacked.
We now show how an optimal container assignment to Proposition 3 Given a schedule with job completion times
job fragments can be derived when the assignment to jobs is C j ∀ j, finding an optimal container assignment is NP-hard.
given.
Proof We prove the NP-hardness by transforming any
instance of the Set Partition Problem (SPP), a known
Proposition 2 Given a container assignment to jobs, w jk
NP-complete problem (Garey and Johnson 1979) into the
∀ j, k, an assignment to job fragments, w̃ f k ∀ f, k, with min-
container assignment decision problem.
imum repacking can be determined in polynomial time.
SPP can be stated as: given a set Y =  {1, . . . , m} and a
Proof We provide an algorithm with a number of steps set A of integers A1 , . . . , Am with B = j∈Y A j , is there a
 
bounded by 2 · J · K . Since each release k can be over- subset Y ⊆ Y such that j∈Y A j = j∈Y \Y A j = B2 ?
lapped by at most one job, the number of job fragments is Let C0 = 0. For family l = 1 construct m jobs with
bounded by 2K . Suppose job j is split into job fragments
with indices f, . . . , g so that f is the first fragment of job j pj = Aj ∀ j = 1, . . . , m
that requires empty containers and g the last fragment. Let d = d j = 2B + 1 ∀ j = 1, . . . , m
S̃ f denote the starting time of fragment f . The algorithm C j = C j−1 + p j ∀ j = 1, . . . , m
proceeds as follows:
and one job m + 2 with
Step 1 Set j = 1. Go to Step 2.
Step 2 If j > J then STOP. B B
Set k = K and go to Step 3. pm+2 = ; dm+2 = 3B + 1; Cm+2 = 2B + + 1.
2 2
Step 3 If w jk > 0 then go to Step 4.
Else set k = k − 1; if k = 0 then set j = j + 1 For family l = L = 2 construct two jobs with
and go to Step 2, else go to Step 3.
Step 4 If rk ≤ S̃g then set w̃gk = min{w jk , p̃g }; pm+1 = B + 1; dm+1 = 2B + 1 = Cm+1
if w jk > p̃g set g = g − 1, w jk = w jk − w̃gk B
pm+3 = 2B + + 1; dm+3 = 5B + 2 = Cm+3 .
and go to Step 4, else set p̃g = p̃g − w̃ f k , 2
k = k − 1 and go to Step 3.
In addition, there are K = 4 releases of empty containers,
Else if rk > S̃g then set w̃ f k = min{w jk , p̃ f };
where k = 1, 3 belong to family l = 1 and k = 2, 4 belong
if w jk > p f set f = f + 1, w jk = w jk − w̃ f k
to family l = 2. The release dates are r1 = r2 = B and
and go to Step 4, else set p̃ f = p̃ f − w jk ,
r3 = r4 = 2B + B2 + 1, and the number of released empties
k = k − 1 and go to Step 3.
is
The idea behind assigning containers from a release k to B
the fragments of job j is as follows: If the containers arrive c1 = B; c3 =
2
before the processing of fragment g (i.e., rk ≤ S̃g ), they are B
assigned to fragment g and no repacking is necessary. On c2 = B + 1; c4 = 2B + +1
2
the other hand, if the containers arrive after the processing of
fragment g, so that they definitely have to be repacked, they Finally, let s = 0, α = γ = 0, β = 2, δ = B + 1 and
are assigned to fragment f , that is, to the first fragment of job Z = 1.5B 2 + B. Note that this SRC instance is in accordance
j that requires empties. This has no effect on the delivery date with the previous assumptions that jobs are indexed in non-
of the job, but it increases the chance that containers from decreasing order of due dates, container releases are indexed
a prior release k with rk ≤ rk can be assigned to fragment in non-decreasing order of release dates, and containers are
g without repacking. A simple interchange argument shows provided early enough to pack a job if it is processed to
that the procedure yields an optimal container assignment for complete at its due date or later.
each job. 
 A schedule for this instance is depicted in Fig. 5.
Obviously, the schedule in the figure is an optimal solu-
Unfortunately, the assignment of containers to jobs is not tion for the scheduling problem without returnable containers
given after the construction of a schedule. Moreover, this since no job is tardy and there are neither earliness penalties
assignment is not a trivial problem since it can have an effect nor setups.

123

B B+1 B/2 B/2 2B + 1
1 ... m m+1 m+2 m+3
r1 = r2 d r3 = r4 dm+2 dm+3
Fig. 5 An optimal schedule for the problem without containers
For the given schedule, construct a container assignment
as follows: Containers from k = 2 are assigned to job m + 1
and those from k = 4 to job m + 3. Jobs j = 1, . . . , m
always need to be repacked, but repacking of job m + 2 can
be avoided by assigning it containers from release k = 1. In
this case, a subset Y ⊂ Y of the jobs processed before r1 are
assigned containers from release k = 3, and these jobs are
tardy because they can only be delivered at r3 . Let wm+2,1
denote the number of containers from release k = 1 reserved
for job m + 2. The total processing time of the jobs in Y is
 ∗ ∗ If there is no such fragment, in the second step the heuristic
j∈Y p j = wm+2,1 + π (wm+2,1 ) where π (wm+2,1 ) ≥ 0
denotes the minimum excess processing time that
 accounts
for the case when there is no subset Y satisfying j∈Y p j =
wm+2,1 .
Then, for 0 ≤ wm+2,1 ≤ B2 the objective value can be
defined as a function of wm+2,1 :
Z (wm+2, 1 ) = β(wm+2,1 + π ∗ (wm+2,1 ))(r3 − d)
+δ(1.5B − wm+2,1 )
B
= 2(wm+2,1 + π ∗ (wm+2,1 ))
2 additional earliness and tardiness penalties while waiting for
+1.5B 2 + 1.5B − wm+2,1 (B + 1)
= 1.5B 2 + 1.5B − wm+2,1 + π ∗ (wm+2,1 )B.
The threshold value Z = 1.5B 2 + B can be achieved
iff w = B2 and π ∗ (wm+2,1 ) = 0 which implies
 m+2,1
j∈Y p j = 2 . In that case, the SPP-instance also has a
B repacking penalties as depicted in Fig. 6.
“yes” answer.
Finally, it is noteworthy that the solution cannot be
improved by changing the schedule. In particular, reducing
repacking below B containers requires to insert idle time
before r1 and completing some job(s) after dm+3 . Yet the
potential savings in repacking do not compensate for the
additional weighted tardiness. 
 to which fragment f belongs) can only be delivered at rk
4.2.2 Container Assignment Heuristic
Due to the NP-hardness of the container assignment prob-
lem, we propose a heuristic to assign containers directly to
job fragments. Each job family is considered separately and
containers can only be assigned to job fragments from the
corresponding family. In each step, the Container Assign-
ment Heuristic will only assign empty containers to a job
fragment if that fragment has not received a sufficient num-
ber of empties during the prior steps.
123
J Sched
f g
rk d˜f rk d˜g
Fig. 6 Non-optimality of the Container Assignment Heuristic
The container releases are considered in decreasing order
of release dates. When assigning the empties from release
k, the heuristic proceeds in three steps. In the first step, the
job fragments that are processed after rk are considered in
decreasing order of their completion times. Assigning emp-
ties from release k to these fragments avoids both repacking
and additional due-date-related penalties.
tries to assign empties to job fragments that are processed
before rk (in increasing order of completion times) and that
have a due date at or after rk . These containers need to be
repacked, but at least it can be avoided that a job cannot
be delivered at its due date because it is still waiting for
containers.
If there is again no such fragment, in the third step the
empties are assigned to job fragments (in decreasing order of
completion times) that are both processed and due before rk .
These containers need to be repacked and the job also incurs
their release.
By assumption, the containers are provided early enough
so that the supplier will not face a shortage of empties unless it
schedules jobs early. If jobs are scheduled early, the supplier
may face a trade-off between due-date-related penalties and
Here, the Container Assignment Heuristic assigns the con-
tainer from release k to fragment g and the container from
release k to fragment f . Yet if the repacking penalty is high,
it may be better to swap the assignment as indicated by the
dotted arrows. In that case, the container from release k needs
not be repacked, but job fragment f (more precisely, the job
and hence incurs inventory holding and tardiness penalties.
4.3 Improvement procedures
Even though the Container Assignment Heuristic does not
necessarily yield optimal assignments, an analysis of exem-
plary problem instances indicated that non-optimal solutions
are mainly caused by non-optimal schedules. Thus the
improvement procedures used here focus on improving the
(initial) schedule by inserting additional idle time and chang-
ing the job sequence.
J Sched
w̃f k = 2
f tion of fragment f until rk . This additional idle time is not
C̃f rk d˜f
Fig. 7 Idle time insertion to avoid repacking
4.3.1 Idle Time Insertion
During the construction of the schedule, the Timetabling
Algorithm inserts idle time based on the jobs’ earliness and
tardiness penalties. Apart from the earliness penalties, early
processing of a job can cause repacking penalties which are
not considered during timetabling. Thus, a solution may be
improved by inserting additional idle time before jobs that
are repacked.
The amount of repacking depends on the assignment of
empty containers to job fragments. The Idle Time Insertion
procedure checks for each job fragment if the solution can be
improved by inserting additional idle time. However, the idle
time has to be inserted before the job to which the fragment
belongs since a job’s processing may not be interrupted.
Note that there is an important difference between due-
date-related penalties and repacking penalties. Any insertion
of idle time decreases the earliness of the subsequent early
jobs, and it increases the tardiness of all other subsequent
jobs. In contrast, inserting idle time does not necessarily
reduce repacking. This is illustrated in Fig. 7.
Here, inserting one unit of idle time before job fragment
f does not reduce the number of containers that need to
be repacked since the empties are still released after the
processing of f . On the other hand, it suffices to insert
three units of idle time to eliminate repacking completely.
In fact, any amount of additional idle time from the interval
[rk − C̃ f + 1, rk − C̃ f + w̃ f k ] will reduce repacking and may
thus yield a better solution.
The Idle Time Insertion procedure considers job frag-
ments in ascending order of their completion times and
container releases in ascending order of their release dates. If
in release k there are containers that are assigned to fragment
f and that need to be repacked, the algorithm proceeds in
three steps.
First, it calculates the amount of idle time that is required
to eliminate repacking completely, i.e., rk − C̃ f + w̃ f k . If
this additional idle time reduces total cost, the schedule is
updated, the procedures Fragment Definition and Container
Assignment Heuristic are rerun, and the algorithm proceeds
to the next container release or the next job fragment, respec-
tively.
Second, if no improvement can be achieved in the first
step, the algorithm verifies if there is any potential for a cost
reduction at all. For that purpose, it calculates the amount of
idle time rk − C̃ f which is required to postpone the comple-
yet sufficient to reduce repacking. However, if it causes an
increase in earliness and tardiness penalties that exceeds the
savings achieved by eliminating repacking completely, then
inserting idle time is not worthwhile. Speaking in terms of
the example in Fig. 7, if the additional penalties caused by
inserting only one unit of idle time are already higher than the
savings achieved if the two containers need not be repacked,
then no additional idle time is inserted and the algorithm
proceeds to the next release.
Third, the algorithm checks if the schedule can be
improved by inserting an amount of idle time from the inter-
val [rk − C̃ f +1, rk − C̃ f + w̃ f k [ so that only some repacking
is avoided. This is done in a way that is similar to many
timetabling algorithms. Starting with rk − C̃ f , the additional
idle time is increased until one of three things happens: either
the maximum additional idle time (i.e., rk − C̃ f + w̃ f k )
is reached, or the processing of one of the jobs that are
scheduled contiguously after fragment f reaches that job’s
delivery date, or all idle time after the last of these jobs is
eliminated. Then the algorithm compares the additional ear-
liness and tardiness penalties with the repacking savings, and
the savings that can be achieved by inserting less additional
idle time. The procedure is repeated until the additional idle
time that would eliminate repacking completely is consid-
ered. If a schedule with a lower total cost has been identified,
then the container assignment is updated using the Fragment
Definition procedure and the Container Assignment Heuris-
tic. Afterwards, the algorithm proceeds to the next release
k + 1.
Whenever additional idle time has been inserted, the algo-
rithm checks if the job that precedes fragment f was early
and can be postponed.
The Idle Time Insertion procedure does not guarantee that
the optimal amount of additional idle time is inserted. In
particular, it only considers the savings that can be achieved if
containers from release k assigned to fragment f need not be
repacked. The procedure tends to underestimate the savings
potential since the insertion of additional idle time may also
reduce repacking for job fragments that are scheduled after
f . However, these fragments may still be postponed since
the procedure considers each fragment in ascending order of
completion times.
4.3.2 Job Interchange
The Job Interchange procedure is similar to that used by
Schaller and Gupta (2008). It aims at finding a better sched-
ule by pairwise interchange of adjacent jobs. Starting with
an initial schedule, candidate schedules are generated by
123

exchanging the positions of two adjacent jobs and running
the Timetabling Algorithm. For each candidate schedule,
the procedures Fragment Definition, Container Assignment
Heuristic, and Idle Time Insertion are executed. If the total
cost of the resulting candidate solution is lower than the total
cost of the original solution, the change is accepted, other-
wise it is rejected and the procedure continues with the job
in the next position.
4.3.3 Greedy Move
The Greedy Move procedure tests several alternative posi-
tions for two candidate jobs. The first candidate is the job that
incurs the highest weighted tardiness among all jobs. Can-
didate schedules are generated by inserting this job at any
earlier position in the sequence and running the Timetabling
Algorithm. For each candidate schedule, the procedures
Fragment Definition, Container Assignment Heuristic and
Idle Time Insertion are executed. The candidate solution with
the highest cost saving is accepted, and the original solution
is sustained if no candidate has a lower total cost. By analogy,
for the job that incurs the highest weighted earliness among
all jobs, we generate candidate schedules by inserting that
job at any later position in the sequence.
4.3.4 Move
The Move procedure constructs new sequences by mov-
ing each job from a batch to the first position of the next
batch of the same family and to the last position of the
prior batch of the same family. The reader is referred to
Schaller and Gupta (2008) for details. For each new sequence,
the procedures Timetabling Algorithm, Fragment Definition,
Container Assignment Heuristic, and Idle Time Insertion are
executed.
4.4 Overview of the algorithm
In summary, the heuristic SRC-H consists of two stages. First,
the procedures Insertion Algorithm, Fragment Definition,
and Container Assignment Heuristic are executed to obtain
an initial schedule and container assignment. The compu-
tational effort to construct the initial schedule is bounded
by O(J 3 log J ) since each job is inserted in no more than
J positions, and the Timetabling Algorithm is bounded by
O(J log J ) (Garey et al. 1988). The initial container assign-
ment can be constructed in O(J 2 ) computational steps, so
that the initial solution can be obtained in O(J 3 log J ).
The procedure Idle Time Insertion which tries to avoid
repacking by inserting additional idle time is bounded by
O(J 4 ). The three procedures that aim at finding better job
sequences each consider at most J 2 sequences. Since the
123
J Sched
Idle Time Insertion procedure is executed for each candidate
schedule, the worst case performance of the Move procedure
is bounded by O(J 6 ). Computational experiments indicated
that better solutions can be found if the improvement proce-
dures are executed repeatedly. That is, whenever a solution
with a lower total cost was found, all improvement proce-
dures are rerun until no further improvement is achieved.
When limiting the number of these reruns to J , the runtime
of SRC-H is bounded by O(J 7 ). Yet our numerical experi-
ments suggest that the improvement procedures are usually
rerun only a few times, and the computational time is negli-
gible even for test problems with 50 jobs.
5 Computational study
In this section, we evaluate the performance of the heuristic
SRC-H in a numerical study. We obtain benchmarks by solv-
ing the mathematical programming formulation from Sect. 3
with a commercial solver for test problems with up to 15
jobs. Larger problems cannot be solved optimally in a rea-
sonable amount of computational time. Nevertheless, we use
the best solutions the solver finds within a runtime of 600 s
to benchmark the performance of SRC-H on problems with
up to 50 jobs.
5.1 Instance generation
Test problems are generated randomly and include 2 and 3
job families with Jl = 3–5 jobs per family, yielding instances
with J = 6 to J = 15 jobs. Job processing times are random
integers from a uniform distribution over [5, 30]. Setup times
are drawn from [1, 5], reflecting empirical observations that
setup times at automotive suppliers account for less than 10%
of machining time (Buxey 1989). Job due dates are drawn

from the interval [( j p j + L s) (1 − τ ∓ 0.5ρ)], where ρ is
the due date range factor and τ the average tardiness factor.
Note that for τ > 0.5ρ it is impossible to complete all jobs
in time. In addition, if ρ is small then all jobs are due within
a short time window. From a practical perspective, it appears
more realisitic that there is no systematic tardiness and that
the due dates are spread over the planning horizon. Hence
we set τ = 0 and ρ = 1.5.
We consider instances with K l = 3–5 releases of empty
containers per family where the number of releases may not
exceed the number of jobs in a family, i.e., K l ≤ Jl . The
underlying assumption is that buyers tend to batch returns of
empties to reduce transportation costs. The number of emp-
ties in a release, ck , is drawn from the interval [ pmin , 2 pmax ]
where pmin and pmax are the processing times of the shortest
and the longest job in a family. For each family, the total num-
ber of empties must coincide with the sum of job processing
times.
J Sched

Recall that by assumption, empty containers are provided Table 1 Solution times of the mathematical program and performance
early enough to pack the jobs unless they are scheduled early. gap of SRC-H
This has to be ensured when generating the release dates of Problem set Av. solution time for Av. % deviation from
the empties. We draw the release dates from the uniform MP in (sec) optimum
L Jl Kl
distribution over [λrkmax , rkmax ]. rkmax is an upper bound on
the release date of release k that is calculated based on the 2 3 3 0.23 0.41
preferred starting times of the jobs in a family and the num- 2 4 3 1.69 1.1
ber of containers in the releases. To illustrate this point, let 2 4 4 4.39 0.44
j denote the job with the latest due date in a family and 2 5 3 78.87 0.39
k the last release of empties. Due to the aforementioned 2 5 4 22.12 0.81
assumption, a sufficient amount of containers for job j must 2 5 5 14.06 0.88
be released until that job’s preferred starting time which is 3 3 3 2.98 0.84
given by d j − p j . Consequently, for release k it must hold 3 4 3 173.16 0.83
that rk ≤ rkmax = d j − p j . However, if release k contains 3 4 4 251.75 0.98
more containers than are required for job j (i.e., ck > p j ),
3 5 3 1392.71 1.02
then the release should take place even before the preferred
3 5 4 1166.48 0.83
starting time of the penultimate job, and so on.
3 5 5 3635.96 0.96
As a result, the availability of empties is usually less
All (1080) 562.03 0.79
restrictive when there are only a few releases per family since
these releases must take place relatively early. As rkmax is only
an upper bound on the release dates that ensures the timeli-
ness of the supply of empties, empties may be provided even
before rkmax . For example, the most unrestrictive scenario Obviously, the heuristic quickly finds (near-)optimal solu-
is that all empties are released at the very beginning of the tions for the test problems with up to 15 jobs. The average
planning horizon so that SRC reduces to a single machine deviation from the optimal solutions is less than 1%, and
earliness-tardiness scheduling problem with batching. We the maximum deviation in one instance is approximately
use the factor λ to influence how early the container releases 48%. The heuristic found the optimal solution in 76% of
occur. Instances are generated for λ ∈ {0.65, 0.8, 0.95}. all instances and deviated from the optimum by less than 5%
The tardiness penalty β and earliness penalty α are drawn in another 19% of the instances.
from uniform distributions over [1, 20], and [1, β], respec- Various analyses were conducted to investigate the effect
tively. This accounts for the common opinion that tardiness of the restricted availability of empty containers. Table 2
is often less desirable than earliness (Wan and Yen 2002). illustrates the average deviations from the optimal solutions
The relative importance of setup and repacking costs is var- categorized by the level of repacking cost. The data suggests
ied during the study by setting the cost of a setup per unit of that SRC-H may perform slightly worse when repacking
setup time, γ , and the cost of repacking one container, δ, to costs increase. However, in general there is no clear indi-
20, 50, and 100 respectively. cation that the performance of the heuristic is influenced by
Ten instances are generated for each parameter constella- the restrictiveness of empty container supply. For example,
tion, yielding a total of 1080 test problems. analyzing the performance gap with respect to λ does not
yield additional insights. This may be due to the assumption
that containers are provided before the job due dates in all the
5.2 Numerical results problems considered here. Notwithstanding, the discussion
in Sect. 1 indicates that this is the scenario which appears to
Optimal solutions for the 1080 test problems are obtained by be most relevant in practice.
solving the mathematical programming formulation with the To investigate the performance of the heuristic on larger
CPLEX 12.2 solver in AIMMS 3.10. The heuristic is coded problems, an additional 720 instances with 20, 30, and 50 jobs
in C++. All computations are run on a computer with a 2.83 are generated. While the heuristic still requires less than 1 s of
GHz CPU and 3.21 GB RAM. computational time for each instance, the commercial solver
Table 1 summarizes the average solution times of the usually does not provide the optimal solution in a reason-
mathematical program (MP) and the average percent devia- able amount of computational time. Observations from the
tion of the heuristic solutions from the optimum provided study of the smaller instances suggest that the solver quickly
by the MP. Computation times for the heuristic are not converges towards (near-)optimal solutions and then requires
reported since they do not exceed a few hundredths of a much time to validate the optimality. Therefore, we impose
second. a runtime limit of 600 s on the solver.

123
 J Sched

Table 2 Average performance gap of SRC-H by the level of repacking Even though earliness and tardiness penalties such as
cost δ inventory holding costs and costs for express deliveries tend
Problem set Av. deviation from OPT in (%) to be higher for larger jobs, weighting these penalties with
L Jl Kl δ = 20 δ = 50 δ = 100 job processing times gives them a high relative importance
compared to setup and repacking costs. Therefore, we also
2 3 3 0.61 0.34 0.29 analyzed the performance for the 1080 test problems with
2 4 3 0.34 1.99 0.97 unweighted penalties. SRC-H is modified slightly for this
2 4 4 0.08 0.38 0.85 problem. In the original heuristic, the Idle Time Insertion pro-
2 5 3 0.47 0.47 0.23 cedure is executed once after the construction of a schedule
2 5 4 0.7 0.47 1.25 and a container assignment. Now, the procedure is repeated
2 5 5 0.57 0.79 1.28 whenever the insertion of additional idle time yielded a
3 3 3 0.88 0.65 0.98 better solution and stops only when no further improve-
3 4 3 0.51 1.01 0.98 ment is achieved. The average computational time required
3 4 4 0.59 1.25 1.11 by the mathematical programming approach increases to
3 5 3 0.55 0.68 1.82 4212.92 s which is caused in particular by instances with
3 5 4 0.87 0.38 1.25 12 and 15 jobs. The average percentage deviation of the
3 5 5 0.81 1.62 0.45 heuristic increases to 2.97%. Both the increase in compu-
All (3 · 360) 0.58 0.84 0.95 tation times and the worse performance of the heuristic may
be explained by the observation that unpromising sequences
incur very high earliness and tardiness penalties in the sce-
Table 3 Average percent deviations from the best-known solution for nario with weighted penalties. Therefore, these solutions can
large instances be ruled out more easily than in the unweighted case. In con-
Problem set Av. deviation from best sol. in (%) sequence, there may be more near-optimal schedules and the
risk of getting stuck in one of these local optima increases.
L Jl Kl MP SRC-H
The quality of the heuristic solutions may be improved by
4 5 4 0.17 1.17 implementing additional local search procedures, such as
4 5 5 0.5 1.12 consolidation and interchange of batches as proposed by
3 10 7 19.35 0.06 Baker (1999).
3 10 8 17.24 0.09
5 6 4 15.07 0.14
5 6 6 13.39 0.05
6 Conclusion
5 10 7 577.75 0
In this paper, we introduce the availability of returnable con-
5 10 8 590.95 0
tainers as a practically relevant and challenging constraint
All (720) 154.3 0.33
for earliness-tardiness scheduling with batching. We show
that this problem is NP-hard in the strong sense and provide
a mathematical programming formulation and a two-stage
Table 3 depicts the average percent deviation of the math- heuristic solution approach. The heuristic requires very small
ematical programming approach and the heuristic from the computational time even on problems with 50 jobs. For prob-
best known solution which is either the solution found by the lems with up to 15 jobs, it usually provides optimal and
solver after the runtime limit, or the SRC-H solution. near-optimal solutions and it outperforms time-limited math-
For problems with 20 jobs, the mathematical program- ematical programming on larger problems.
ming approach on average yields slightly better solutions This paper opens up some promising fields for further
than the heuristic which in return is much faster. For instances research. Apparently, only small problem instances can be
with 30 and 50 jobs, the solutions from SRC-H are usually solved to optimality in a reasonable computational time
better and obtained faster than those from the mathemati- using standard commercial solvers. Consequently, problem-
cal programming approach. Even when the runtime limit of specific optimal solution procedures can be developed for
the solver is increased to 3600 s for the instances with 50 instances with 20 jobs and more. In particular, time-indexed
jobs, the MP does usually not provide better solutions than problem formulations have turned out useful to derive lower
SRC-H. Apparently, SRC-H quickly obtains (near-)optimal bounds for earliness-tardiness problems (Sourd and Kedad-
solutions for problems with approximately 20 jobs, and it Sidhoum 2008) and such an approach could be extended to
outperforms the mathematical programming approach with incorporate the container assignment decisions. Second, for
a runtime limit on instances with up to 50 jobs. practical applications it may also be useful to study the prob-

123
J Sched
lem variant where jobs may be processed as well as delivered
preemptively since this approach allows for more flexible
lot-sizing. Modifying the heuristic SRC-H for an item com-
pletion time setting may be a good starting point in that
direction. Finally, despite the practical relevance relatively
little research seems to have been done on operations man-
agement problems involving reusable packaging. Problems
such as two-stage production and distribution scheduling
models with returnable containers clearly deserve more
research.
References
Allahverdi, A., Gupta, J. N. D., & Aldowaisan, T. (1999). A review of
scheduling research involving setup considerations. Omega, 27(2),
219–239.
Allahverdi, A., Ng, C., Cheng, T., & Kovalyov, M. Y. (2008). A survey of
scheduling problems with setup times or costs. European Journal
of Operational Research, 187(3), 985–1032.
Arkin, E.M., & Roundy, R.O. (1988). A pseudo-polynomial time algo-
rithm for weighted tardiness scheduling with proportional weights
Technical Report No. 812, College of Engineering, Cornell Uni-
versity.
Azizoglu, M., & Webster, S. (1997). Scheduling job families about an
unrestricted common due date on a single machine. International
Journal of Production Research, 35(5), 1321–1330.
Baker, K. R. (1999). Heuristic procedures for scheduling job families
with setups and due dates. Naval Research Logistics, 46(8), 978–
991.
Baker, K. R., & Scudder, G. D. (1990). Sequencing with earliness and
tardiness penalties: A review. Operations Research, 38(1), 22–36.
Buxey, G. (1989). Production scheduling: Practice and theory. European
Journal of Operational Research, 39(1), 17–31.
Chrysler, L.L.C. (2009). Packaging and shipping instructions. https://
cda.extra.chrysler.com/icon/mpe/files/ChryslerPckgShpgInstr3_
09_2_. Accessed 13 January 2013.
Coia, A. (2013). Gleaming the cube. Automotive Logistics, 16(1), 36–
40.
Coia, A. (2014). Getting to the point of return. http://
www.automotivelogisticsmagazine.com/intelligence/
getting-to-the-point-of-return. Accessed 7 March 2014.
Del Castillo, E., & Cochran, J. K. (1996). Optimal short horizon dis-
tribution operations in reusable container systems. Journal of the
Operational Research Society, 47(1), 48–60.
Garey, M. R., & Johnson, (1979). Computers and intractability—A
guide to the theory of NP-completeness. New York: Freeman.
Garey, M. R., Tarjan, R. E., & Wilfong, G. T. (1988). One-processor
scheduling with symmetric earliness and tardiness penalties. Math-
ematics of Operations Research, 13(2), 330–348.
Hofmann, E., & Bachmann, H. (2006). Behälter-Management in der
Praxis. Hamburg: Deutscher Verkehrs-Verlag. (in German).
Kärkkäinen, M., Ala-Risku, T., & Herold, M. (2004). Managing the
rotation of reusable transport packaging—A multiple case study.
In Thirteenth International Working Seminar on Production Eco-
nomics.
Kroon, L., & Vrijens, G. (1995). Returnable containers: An example of
reverse logistics. International Journal of Physical Distribution &
Logistics, 25(2), 56–68.
Lackner, E., & Zsifkovits, H. (2006). Die Rolle von Behältern in der
supply chain. (in German) In C. Engelhardt-Nowitzki (Ed.), Char-
genverfolgung: Möglichkeiten, Grenzen und Anwendungsgebiete
(pp. 241–256). chap. Die Rolle von Behältern in der Supply:
Springer.
Potts, C. N., & Kovalyov, M. Y. (2000). Scheduling with batching: A
review. European Journal of Operational Research, 120(2), 228–
249.
Robert Bosch GmbH (2007). Supplier logistics manual, release
3.0.http://purchasing.bosch.com/download/LHL_V_3_0_en.
Accessed 30 December 2012.
Schaller, J. (2007). Scheduling on a single machine with family setups
to minimize total tardiness. International Journal of Production
Economics, 105(2), 329–344.
Schaller, J. E., & Gupta, J. N. (2008). Single machine scheduling with
family setups to minimize total earliness and tardiness. European
Journal of Operational Research, 187(3), 1050–1068.
Schmölzer, T., & Schöfer, J. (2005). Bedarfsorientiertes Behälter-
management zur Kostenreduzierung in der Automobilindus-
trie.Zeitschrift für die gesamte Wertschöpfungskette Automobil-
wirtschaft, 56–60.
Sourd, F. (2005). Earliness-tardiness scheduling with setup considera-
tions. Computers & Operations Research, 32(7), 1849–1865.
Sourd, F. (2006). Dynasearch for the earliness-tardiness scheduling
problem with release dates and setup constraints. Operations
Research Letters, 34(5), 591–598.
Sourd, F., & Kedad-Sidhoum, S. (2008). A faster branch-and-bound
algorithm for the earliness-tardiness scheduling problem. Journal
of Scheduling, 11(1), 49–58.
Wan, G., & Yen, B. P. C. (2002). Tabu search for single machine schedul-
ing with distinct due windows and weighted earliness/tardiness
penalties. European Journal of Operational Research, 142(2),
271–281.
Yates, C., & Wyant, S. (2012). Navistar engine group sup-
plier guidelines February 2012. http://www.navistarsupplier.com/
Documents/DO000D01. Accessed 13 January 2013.
Yildiz, H., Ravi, R., & Fairey, W. (2010). Integrated optimization of
customer and supplier logistics at Robert Bosch LLC. European
Journal of Operational Research, 207(1), 456–464.
123