An Efficient Polynomial-Time Approximation
Scheme for the Joint Replenishment Problem
Tim Nonner?
Maxim Sviridenko??
IBM Research - Zurich
University of Warwick
Abstract. We give an efficient polynomial-time approximation scheme
(EPTAS) for the Joint Replenishment Problem (JRP) with stationary
demand. Moreover, using a similar technique, we give a PTAS for the
capacitated JRP with non-stationary demand but constant size capacities.
1
Introduction
The joint replenishment problem (JRP) with stationary demand is one
of the fundamental problem in inventory management, dating back to a
paper of Naddor and Saltzman [10] but probably even further. It it arguably the simplest extension of the even more prominent problems of
finding the economic order quantity (EOQ) for a single item [5], that
is, given stationary demand, a fixed holding cost per unit, and a fixed
cost for a single order, the order quantity that optimally balances holding
and ordering cost over time. JRP also aims to optimally balance holding and ordering cost, but for the case of multiple items with a common
ordering cost, modeling the fact that production or transportation processes often require some setup cost which is independent of how much
and what is produced or ordered, respectively. However, in contrast to
the single item case where a simple EOQ-policy is optimal, an optimal
replenishment policy for JRP might have a complicated non-stationary
structure with changing inter-replenishment times [1,9], motivating the
use of restricted policies. Roundy [12] showed in a seminal paper that
policies with power-of-two ratios between inter-replenishment times yield
an 1.02-approximation, see also [9] for an overview and [6,16] for some
improvements and extensions. Power-of-two policies can be relaxed by allowing arbitrary periodic inter-replenishment times. In this case, finding
an optimal policy is at least as hard as factoring, as recently pointed out
?
??
tno@zurich.ibm.com
M.I.Sviridenko@warwick.ac.uk, Work supported by EPSRC grant EP/J021814/1,
FP7 Marie Curie Career Integration Grant and Royal Society Wolfson Merit Award.
by Schulz and Telha [13], and hence it is unlikely to find a polynomial-time
algorithm.
All these policies are quite restrictive since they require periodicity of
all replenishment cycles, leading to sub-optimal solutions. A reasonable
trade-off is to periodically repeat a non-periodic policy for a finite time
horizon. Indeed, Adelman and Klabjan [1] showed that such policies offer
an 1 + -approximation for an arbitrary small > 0. Once restricted to a
finite time horizon, it is natural to partition this horizon into equal-length
periods, moving into the realm of combinatorial optimization. Quite recently, Segev made the first major progress since years for this case by
presenting a QPTAS [14], which shows that it is probably not APX-hard,
and thus motivating the search for other approximation schemes.
In contrast to the infinite-horizon case where relatively little is known
about the complexity [13], Arkin, Joneja, and Roundy [3] showed that
the finite-horizon case is strongly NP-hard for non-stationary demand.
On the other hand, there has been a line of approximation results for this
case during the last decade [7,8,11,15], even in the more general setting
of the one-warehouse multiple-retailer problem with non-linear holding
cost. Nonner and Souza [11] showed that this setting is APX-hard and
therefore does not admit a polynomial-time approximation scheme, that
is, an algorithm that has performance guarantee 1 + ε and polynomial
running time for any ε > 0. On the other side, the basic question whether
JRP with non-stationary demand and linear holding cost is APX-hard
(and hence does not admit any approximation scheme, unless P=NP)
remains open.
Constributions. Our main contribution is an efficient polynomialtime approximation scheme (EPTAS) for JRP with finite time horizon
and stationary demand. Specifically, for any > 0, we design an 1 + ελ
approximation
algorithm with running time O(λ2λ 22 (N T 2 + T 5 )) for
√
λ = 4 2 , where T is the number of periods of the finite time horizon,
and N is the number of items. Note here our assumption that the input
T is polynomial, which is reasonable once we move to the finite time
horizon case. Using a similar technique, we also give a PTAS for the nonstationary demand case with soft capacitated single item orders, that is,
for each item i, therelis am constant Ci such that ordering y units results
in item ordering cost Cyi Ki , where Ki is the cost of a single order. This
makes especially sense from a practical point of view, since item orders
might be delivered in small batches of size Ci , each implying cost Ki ,
for example with trucks having limited capacity, but common orders are
delivered in huge quantities with comparably small capacity constraints,
for example with container ships. It is worth mentioning here that this
case is still strongly NP-hard, which is a simple consequence of the fact
that JRP with non-stationary demand is NP-hard even if each item faces
only three times exactly demand 1 [11]. Consequently, to the best of our
knowledge, this is the first approximation scheme for a natural NP-hard
variant of JRP with non-stationary demand.
Preliminaries. Throughout this paper, we consider the case of a
finite time horizon partitioned into periods 1, 2, . . . , T of equal length,
w.l.o.g. say 1. We label the items 1, 2, . . . , N , and let integers dit ≥ 0 denote the demand for item i in time period t. Hence, in case of stationary
demand, the dit are equal for each item i, denoted di . We assume that
demand arrives at the end of the corresponding time period, but we are
allowed to order at the beginning of each time period. Therefore, stock is
held in inventory for at least one period. Each order implies a common ordering cost K0 , independent of the number of involved items and the size
of the order. However, for each involved item i, we obtain an additional
item ordering cost Ki , which is also independent of the size of the order.
We also consider the case that item ordering
cost are size-dependent such
l m
y
that ordering y units results in cost Ci Ki for some constant Ci , called
soft capacitated case. Holding one unit of item i for one period results in
holding cost hi . Demand needs to be satisfied with items on stock, and
hence no backlogging is allowed, called make-to-stock scenario. Consequently, since we may w.l.o.g. assume that there is at least one item with
demand in the first period, there needs to be a common order in the first
period. The objective is to find an optimal ordering schedule σ, that is, a
schedule that minimizes cost(σ), the sum of ordering and holding costs of
all items. Let σ ∗ be an optimal schedule with cost(σ ∗ ) = OPT. Observe
that for each item i , we may assume that the time horizon 1, 2, . . . , T is
partitioned into order intervals. Specifically, each order interval has the
formP
{a, . . . , b} with starting and ending periods a and b, respectively,
and bt=a dit units of item i are ordered in period a in order to satisfy
the demand between periods a and b, that is di,a , di,a+1 , . . . , di,b . Since we
assume that all periods have length 1, we obtain that this order interval
has length x = b − a + 1, that is, the maximal number of periods stock is
held in inventory in this order interval. Consequently, observe that if we
are in the stationary demand case with demand di per period, then the
holding cost associated with the order in period a is exactly x(x+1)
di hi .
2
Because this definition of order intervals ensures that the stock of item
i will be empty at the start of each order interval, this is called zeroinventory ordering policy (ZIO). In is clear that in our setting there is an
optimal ZIO policy. Finally, for an interval of periods I = {a, . . . , b} and
some period t, we write t ≥ I if and only of t ≥ a, and t > I if and only if
t > b. For simplicity, we sometimes do not distinguish between an order
and the period it is executed.
Basic techniques. One way to solve JRP is to enumerate all possible
sets of common orders W ⊆ {1, . . . , T }. For each such set W and item
i, the optimal orders for item i can then be found by solving a singleitem lot-sizing problem [4,2] with the constraint that only periods from
the set W may be used as orders. Therefore, the running time of this
algorithm is 2T N times the running time to solve the single-item lotsizing problem, and thus exponential in the input T . An alternative way
to solve JPR is to build a dynamic programming table, where each entry
considers a subproblem defined by an interval of periods {a, . . . , b}, i.e.,
this subproblem contains all items i and their demands between periods
a and b. To fill such a table, we could decompose this interval into two
subintervals {a, . . . , t} and {t + 1, . . . , b} at some period a ≤ t < b to
define a recursion. However, this is not a valid decomposition, since we
need to know for each item i the stock level at the end of period t, we
also say that this stock is held toPperiod t + 1. Since this stock level
could be as large as D := maxi t dit , trying all possible stock level
patterns results in a factor DN , making such an approach infeasible. For
the case of stationary demand, Segev [14] used such an approach to obtain
a QPTAS. However, it is worth mentioning here that the way he trades the
problem size for accuracy is completely different from ours. Specifically,
he trades the number of items for accuracy, whereas we basically round
the positions of item orders. Therefore, both techniques could also be
applied in sequence.
Outline. We combine both approaches explained above. Specifically,
we do several recursions as in the DP, and then we switch to an enumeration approach. The point when we switch needs to be individually
triggered for each item. Hence, the problem is to incorporate all this into
a single DP. To this end, we need the shifting procedure explained in Section 2, which builds a hierarchical random tree decomposition of the time
horizon. Next, we utilize this decomposition in the main DP described in
Section 3. The major bottleneck is its recurrence relation, which would
only yield a PTAS if implemented straight-forward, as explained in Section 4. To avoid this, we present an approximate recurrence relation in
Section 5 that is based on a different helper DP. Then, in Section 6, we
show that combining this approximate recurrence relation with the main
DP from Section 3 gives an EPTAS for JRP with stationary demand.
Finally, in Section 7, we conclude with an adaption of the PTAS to the
case of non-stationary demand but soft capacitated item orders. Note that
we could simplify the DP in both cases, but for the sake of exposition,
we think that it is more convenient to present a general DP that covers
everything.
2
Tree Decomposition of Time Horizon
We are given a constant integer λ, which we will define later on, but the
goal is that the approximation ratio goes to 1 as λ → ∞. Let then κ be
a random integer drawn uniformly at random from {1, . . . , λ}. Moreover,
assume that the number of periods T is a power of 2. This assumption
simplifies the description of DP. In general, to avoid this assumption, we
could also partition the time horizon into intervals of roughly the same
length instead of exactly the same length, as explained in the following
paragraph.
We now inductively construct a random tree G whose nodes are intervals of periods with the property that an interval I 0 ∈ G is a successor
(or child) of another interval I ∈ G if and only if I 0 ⊆ I. To start this
inductive construction, let I = {1, . . . , T } be the root of G. We then obtain the children of I by partitioning I into 2κ many subintervals of equal
length T /2κ . Next, we partition these children into 2λ many subintervals
of equal length T /2κ+λ , and so on. This clearly defines the tree of intervals G. It might happen that some intervals I are not large enough to be
partitioned into 2λ subintervals. In this case, we partition I into intervals
each containing a single period, which will be the leaves of G. Let lI denote the level of an interval I ∈ G, where the root {1, . . . , T } has level 0.
Note that if lI ≥ 1, then the length |I| of I is exactly T /2λ(lI −1)+κ . For
each intervals I, let cI denote the number of children of I in G if there
are any. We have that cI ≤ 2λ = O(1). Finally, observe that |G| = O(T ),
independent of λ.
In the following sections, we use different base values χi for each item
i which characterize the properties of item i in a single number with
respect to Ki , and hi , and its demand. In addition, we define a level li for
each item i. Specifically, if χi > T /2, then we define li := 0. Otherwise,
let li be the maximal level such that the lengths of all intervals I with
lI = li are at least as large as χi , i.e., χi ≤ T /2λ(li −1)+κ if li > 0. Note
that the length of the intervals I with lI = li + 1 are then strictly smaller
than χi . However, since κ is random, we do not know how much larger
and smaller the intervals at levels li and li + 1 are, respectively. We need
this to deal with arbitrary base values χi . We obtain the following simple
lemma (proof in full version).
Lemma 1. It holds that
(1) for any item i, the expected length of each interval I with lI = li + 1
i
is at most 2χ
λ ,
(2) for any item i, the expected number of intervals I with level lI = li is
at most 1 + χ2Ti λ .
3
Dynamic Program
In this section, we describe a DP which can be adapted to the case of
stationary demand as well as the case of non-stationary demand with
soft capacitated item orders. To this end, we restrict the search space to
canonical schedules, where the properties of a canonical schedule σ are
that
(1) for any item i and interval I ∈ G with lI = li , no stock of item i is
held to the period r of the first common order in interval I, that is,
the stock of item i is empty after period r − 1,
(2) for any item i and interval I ∈ G with lI = li + 1, if item i orders in
interval I, then the period of this item order is the period of the first
common order in this interval.
To compute an optimal canonical schedule, we have a DP array Π with
entries Π(I, r, s), where I is a non-leaf interval in the tree G defined in
Section 2, and r and s are periods with r ≤ s, r ≥ I, and s > I. Recall
that we write r ≥ I = {a, . . . , b} if and only of r ≥ a, and r > I if and
only if r > b. For technical reasons, we moreover allow that r = s = T +1.
Note that T + 1 is not officially a period, since the last period is T . The
size of Π is hence O(T 3 ) since |G| = O(T ), and therefore polynomial.
We will first explain how to fill Π without further explanations, and then
show some properties of the entries of Π. Array Π is initialized as follows:
(1) We set Π(I, r, s) = 0 for r P
> I.
(2) We set Π(I, r, s) = K0 + i Φi (r, s) for each leaf interval I = {a}
in G and r = a, where Φi (r, s) is the cost of an optimal schedule for
the subproblem consisting of item i and its demand between periods
r and s − 1, that is, di,r , di,r+1 , . . . , di,s−1 , subject to the constraint
that there can only be an item order in period r. Hence, if there is
demand between these periods, then there needs to be such an order,
and otherwise not.
To define the recurrence relation, consider some fixed entry Π(I, r, s).
We may assume that r ≤ b, because the initialization makes the case
r > b trivial. Moreover, let I1 , I2 , . . . , IcI be the natural ordering of the
children of I in G. Let then E(I, r, s) denote the set of all period sequences
e1 = r ≤ e1 ≤ . . . ≤ ecI +1 = s such that for each 1 ≤ z ≤ cI , ez ≥ Iz , and
if even ez > Iz , then ez = ez+1 . For each such sequence e ∈ E(I, r, s) and
item i, let Φi (I, e) be the cost of an optimal schedule for the subproblem
which consists only of item i and its demands between periods r and s − 1
with the constraint that all item orders need to be selected from the set
of periods {e1 , e2 , . . . , ecI }. Finding this schedule is basically a single-item
lot-sizing problem which can be solved in polynomial time. For instance,
with the classical algorithm of Federgruen and Tzur [4] in O(cI log cI )
time, or even in O(cI ) time with an algorithm from Aggarwal, Alok, and
Park [2]. Using these definition, we are ready to state the recurrence
relation:


cI
X

X
Φi (I, e) +
Π(Iz , ez , ez+1 )
(1)
Π(I, r, s) = min

e∈E(I,r,s) 
i:li =lI
z=1
Since cI = O(1), we have the simple polynomial upper bound T cI −1 on
the number of sequences in E(I, r, s). This shows that this recurrence
relation can be implemented in polynomial time. Specifically, because cI
might be as large as 2λ and we need to solve at most N single-item lotsizing problems with cI periods, we obtain the following lemma.
λ
Lemma 2. The recurrence relation can be solved in O(T 2 −1 N 2λ ) time,
and hence the complete array Π can be filled in polynomial time.
However, the exponent of the running time given in Lemma 2 contains
λ, a parameter which we will need to set with respect to the required
precision later on. Therefore, using this recurrence relation can only yield
a PTAS. To avoid this drawback for the case of stationary demand, we will
present an approximate recurrence relation which can be implemented
more efficiently in the next Section 5. The following lemma is a direct
consequence of the definition of the recurrence relation and states the
required properties.
Lemma 3. Array Π gets filled such that each entry Π(I, r, s) with r ∈ I
satisfies Π(I, r, s) = cost(σ), where σ is an optimal canonical schedule for
the subproblem consisting of all items i with li ≥ lI and their demands
between periods r and s − 1 subject to the constraint that only orders in
I are allowed.
Consider now the realization σ of the entry Π(I, r, s) for I = {1, . . . , T },
r = 1, and s = T + 1. By Lemma 3 we derive that σ is an optimal canonical schedule for the complete instance. Recall here the initial assumption
that there needs to be a common order in the first period r. We conclude
that we need to argue in the following Sections 4 and 7 that there is a
feasible canonical schedule which is 1 + -close to an optimal one.
Π( I, r, s )
Π( I2 , e2 , e3 )
e1 = e2 = r
I1
I2
Π( I4 , e4 , e5 )
e3 = e4
I3
e5 = s
I4
Fig. 1. Example recurrence relation
Example. To illustrate the recurrence relation, let us consider a simple example for an interval I with four children I1 , I2 , I3 , I4 . Moreover,
assume that the optimal sequence e1 ≤ e1 ≤ . . . ≤ e5 satisfies the properties e3 = e4 ∈ I4 and e1 = e2 ∈ I2 , as depicted in Figure 3. Therefore,
since consequently Π(I1 , e1 , e2 ) = Π(I3 , e3 , e4 ) = 0, the right part of the
recurrence relation is simply Π(I2 , e2 , e3 ) + Π(I4 , e4 , e5 ), which translates
to the cost added by the common orders and the items i with li > lI . Since
then li ≥ lI2 = lI4 , Property (1) in the definition of a canonical schedule
says that no demand is held to periods e2 and e4 at any such item i.
Therefore, periods e2 and e4 decompose the instance for such items as
schematically depicted in Figure 3. The dashed lines schematically depict
one possible final realization. Observe that we are not allowed to do any
ordering in interval I3 , but there might be common orders in I2 and I4
except e2 and e4 , respectively. On the other hand, the left part of the recurrence relation translates to the cost added by the items i with li = lI .
To satisfy Property (2) in the definition of a canonical schedule, we are
only allowed to pick item orders with periods from the set or periods
{e2 , e4 }, which is exactly what we do in an optimal way by the definition
of Φi (I, e).
4
PTAS for Stationary Demand
In this section, we show that the DP from Section 3 yields
q a PTAS for
the stationary demand case when using base values χi := dKi hii . We need
the following lemma (proof in full version).
√
Lemma 4. There is a canonical schedule σ with E [cost(σ)] ≤ (1+ 2 λ 2 )OPT.
Theorem 1. There exists a polynomial-time approximation scheme for
the Joint Replenishment Problem with stationary demand.
Proof. We know from Lemma 4 that
√ there is a canonical schedule σ with
E [cost(σ)] ≤ (1+)OPT for λ = 2 2/. On the other hand, Lemma 3 implies that our dynamic programming algorithm yields an optimal canonical schedule, which can be done in polynomial time because of Lemma 2
for any constant λ. The claim follows by combining both facts. Note that
this construction can be derandomized by enumerating all possible values
κ in the construction of tree G.
t
u
5
Approximate Recurrence Relation
We can think of a schedule as a set of common orders W ⊆ {1, . . . , T }, and
for each item i, a set of item orders Ri ⊆ W . The critical property is that
the item orders are subsets of the common orders. We slightly modify this
to generate canonical pseudo-schedules. Specifically, a canonical pseudoschedule is defined by a set of common orders W ⊆ {1, . . . , T } and for each
item i, a set of item orders Ri , such that Property (1) from the definition of
a canonical schedule is satisfied, and additionally the property that (2) for
any item i and interval I ∈ G with lI = li + 1, if W ∩ I 6= ∅ (i.e., there is a
common order in interval I) then Ri contains exactly the first period in I.
Hence, we do not have a strict subset relation, and therefore, in contrast to
a canonical schedule, a canonical pseudo-schedule is not feasible. However,
we consider canonical pseudo-schedules as a helper construction.
Our goal is to modify the DP from Section 3 such that it computes
an optimal canonical pseudo-schedule using an approximate recurrence
relation. To this end, consider a fixed entry Π(I, r, s) which we want to
fill, and let I1 , I2 , . . . , IcI be the children of I in G. Then, for some sequence
e ∈ E(I, r, s), let e ∈ E(I, r, s) be the sequence with the property that for
each 1 ≤ z ≤ cI , ez is the first period in interval Iz 0 such that ez ∈ Iz 0 .
Intuitively, we can think of e as a rounding of sequence e to first periods
in intervals I1 , I2 , . . . , IcI . Let E(I, r, s) ⊆ E(I, r, s) denote the subset of
all such rounded sequences. Replacing Φi (I, e) by Φi (I, e) in recurrence
relation (1) gives us a new recurrence relation, which we call approximate
recurrence relation. The following adaption of Lemma 3 is an immediate
consequence of the rounding of sequences.
Lemma 5. Using the approximate recurrence relation, array Π gets filled
such that each entry Π(I, r, s) with r ∈ I satisfies Π(I, r, s) = cost(σ),
where σ is an optimal canonical pseudo-schedule for the subproblem consisting of all items i with li ≥ lI and their demands between periods r and
s − 1 subject to the constraint that only orders in I are allowed.
We will argue that the approximate recurrence relation can be implemented much more efficiently because there are far less sequences in
E(I, r, s) than in E(I, r, s). Specifically, the number drops from at most
T cI −1 to 2cI −1 , which implies the following lemma (proof in full version).
λ
Lemma 6. The approximate recurrence relation can be solved in O(2λ 22 (N +
T 2 )) time.
Lemma 7. Array Π in combination with the approximate recurrence reλ
lation can be filled in O(2λ 22 (N T 2 + T 5 )) time.
Proof. The claim follows by multiplying the time needed to solve the
approximate recurrence relation given in Lemma 6 with the size of Π.
λ
Note that this would give running time O(2λ 22 (N + T 2 )T 3 ). However,
since for each item i, the value Φi (I, e) needs to be computed only in
recurrence relations which fill entries of the form Π(I, r, s) with lI = li ,
λ
we obtain running time O(2λ 22 (N T 2 + T 5 )).
t
u
6
EPTAS for Stationary Demand
Note that there is a straightforward way to turn a canonical schedule σ
into a canonical pseudo-schedule σ and vice versa. Specifically, for any
item i and interval I with lI = li + 1, if σ has an order in interval I for
item i, which needs to be in the same period as the first common order in
this interval by the definition of a canonical schedule, replace this order
by an order in the first period of interval I. This transformation defines
a canonical pseudo-schedule σ.
Analogously, given a canonical pseudo-schedule σ, for each item i and
interval I with lI = li + 1, if σ has an order in the first period of interval
I for item i, then we just move it forward until we find the first common
order in that interval. Such an order must exist by the definition of a
canonical pseudo-schedule σ. Also this transformation defines the corresponding canonical schedule. We obtain the following lemma (proof in
full version).
Lemma 8. It holds that
(1) let σ be
schedule
(2) let σ be
schedule
the canonical pseudo-schedule generated from a canonical
√
σ as explained above, then E [cost(σ)] ≤ cost(σ) + λ2 OPT,
the canonical schedule generated from a canonical√pseudoσ as explained above, then E [cost(σ)] ≤ cost(σ) + λ2 OPT.
Now we are ready to prove the main theorem.
Theorem 2. There exists an efficient polynomial-time approximation scheme
for the Joint Replenishment Problem with stationary demand. For √
any
λ
4 2
λ
2
2
5
precision > 0, the running time is O(λ2 2 (N T + T )) for λ = .
Proof. We know from√ Lemma 4 that there is a canonical schedule σ with
E [cost(σ)] ≤ (1 + 2 λ 2 )OPT. Therefore, by the first part of Lemma 8
and linearity of expectation, we obtain
that there is a canonical pseudo√
3 2
schedule σ with E [cost(σ)] ≤ (1+ λ )OPT. On the other hand, Lemma 5
shows that using the DP in combination with the approximate recurrence
relation yields an optimal canonical pseudo-schedule σ ∗ with cost(σ ∗ ) ≤
cost(σ), and the second part of Lemma 8 gives that we can
turn σ ∗
√
into a canonical schedule σ 0 with E [cost(σ 0 )] ≤ cost(σ ∗ ) + λ2 OPT ≤
(1 +
√
4 2
λ )OPT.
This proves the claim in combination with Lemma 7.
√
Specifically, we obtain approximation ratio 1 + for λ = 4 2 . Finally,
note that this construction can be derandomized by enumerating all possible values κ in the construction of tree G. This adds another factor λ
to the running time.
t
u
7
Soft Capacitated Item Orders
The goal of this section is to prove the following theorem for base values
i
χi = K
hi (proof in full version).
Theorem 3. The DP yields a polynomial-time approximation scheme for
the Joint Replenishment Problem with non-stationary demand but soft
capacitated item orders.
References
1. Daniel Adelman and Diego Klabjan. Duality and existence of optimal policies in
generalized joint replenishment. Mathematics of Operations Research, 30(1):pp.
28–50, 2005.
2. Alok Aggarwal and James K. Park. Improved algorithms for economic lot size
problems. Oper. Res., 41(3):549–571, May 1993.
3. E. Arkin, D. Joneja, and R. Roundy. Computational complexity of uncapacitated
multi-echelon production planning problems. Operations Research Letters, 8(2):61–
66, 1989.
4. Awi Federgruen and Michal Tzur. A simple forward algorithm to solve general
dynamic lot sizing models with n periods in O(n log n) or O(n) time. Management
Science, 37(8):909–925, August 1991.
5. F.W. Harris. Operations cost (Factory Management Series). A. W. Shaw Co.,
Chicago, IL., 1915.
6. P. Jackson, W. Maxwell, and J. Muckstadt. The joint replenishment problem with
power-of-two restriction. AIIE Trans., 17:25–32, 1985.
7. Retsef Levi, Robin Roundy, and David B. Shmoys. Primal-dual algorithms for
deterministic inventory problems. Mathematics of Operations Research 31, pp.
267–284, 2006.
8. Retsef Levi, Robin Roundy, David B. Shmoys and Maxim Sviridenko. A constant
approximation algorithm for the one-warehouse multi-retailer problem. Management Science 54, pages 763–776, 2008.
9. Roundy R. Muckstadt J. Handbooks in Operations Research and Management
Science: Analysis in Multi-Stage Production Systems, pages 59– 131. Elsevier,
1993.
10. Eliezer Naddor and Sidney Saltzman. Optimal reorder periods for an inventory
system with variable costs of ordering. Operations Research, 6:676–685.
11. Tim Nonner and Alexander Souza. Approximating the joint replenishment problem
with deadlines. Discrete Mathematics, Algorithms and Applications, 1(2):153–173,
2009.
12. Robin Roundy. 98%-effective integer-ratio lot-sizing for one-warehouse multiretailer systems. Management Science, 31(11):pp. 1416–1430, 1985.
13. Andreas S. Schulz and Claudio Telha. Approximation algorithms and hardness
results for the joint replenishment problem with constant demands. In Proceedings
of the 19th Annumal European Symposium on Algorithms (ESA’11), pages 628–
639, 2011.
14. Danny Segev. An approximate dynamic-programming approach to the joint replenishment problem, manuscript, 2012.
15. Gautier Stauffer, Guillaume Massonnet, Christophe Rapine, and Jean-Philippe
Gayon. A simple and fast 2-approximation algorithm for the one-warehouse multiretailers problem. In Proceedings of the 22nd Annual ACM-SIAM Symposium on
Discrete Algorithms (SODA’11), pages 67–79, 2011.
16. Chung-Piaw Teo and Dimitris Bertsimas. Multistage lot sizing problems via randomized rounding. Operations Research, 49(4):599–608, July 2001.