Polynomial Time Algorithms for Stochastic

Uncapacitated Lot-Sizing Problems

Yongpei GuanSchool of Industrial Engineering, University of Oklahoma, Norman, OK 73019,

U.S.A, yguan@ou.edu

Andrew J. MillerDepartment of Industrial and Systems Engineering, University of Wisconsin, Madison, WI 53706,

U.S.A, amiller@engr.wisc.edu

Submitted: June 2006; Revised: January 2007 and June 2007

Abstract

In 1958, Wagner and Whitin published a seminal paper on the deterministic uncapacitated

lot-sizing problem, a fundamental model that is embedded in many practical production planning

problems. In this paper we consider a basic version of this model in which demands (and other

problem parameters) are stochastic: the stochastic uncapacitated lot-sizing problem (SULS). We

define the production path property of an optimal solution for our model and use this property to

develop a backward dynamic programming recursion. This approach allows us to show that the

value function is piecewise linear and right continuous. We then use these results to show that a

full characterization of the optimal value function can be obtained by a dynamic programming

algorithm in polynomial time for the case that each non-leaf node contains at least two children.

Moreover, we show that our approach leads to a polynomial time algorithm to obtain an optimal

solution to any instance of SULS, regardless of the structure of the scenario tree. We also show

that the value function for the problem without setup costs is continuous, piecewise linear, and

convex, and therefore an even more efficient dynamic programming algorithm can be developed

for this special case.

Key words: Lot-sizing; stochastic programming; dynamic programming.

Subject classification: Production/scheduling: Planning; Programming: Integer, stochastic.

Area of review: Optimization.

1

1 Introduction

The deterministic uncapacitated lot-sizing problem (ULS) is the problem of determining the amount

to produce in each time period over a finite discrete horizon so as to satisfy the demand for each pe-

riod while minimizing the summation of setup, production, and inventory holding costs (Nemhauser

and Wolsey (1988), Wolsey (1998), Pochet and Wolsey (2006)). This fundamental model, first in-

troduced by Wagner and Whitin (1958), is embedded within many practical production planning

problems. It is easily seen to be fixed-charge flow problem in a network composed of a directed path

and a dummy production node, and understanding and exploiting this structure has been essential

in developing approaches to complicated, real-world problems (see, for example, Tempelmeier and

Derstroff (1996), Belvaux and Wolsey (2000), Belvaux and Wolsey (2001), Stadtler (2003), and

many others).

Polynomial time algorithms for the deterministic ULS are based on the Wagner-Whitin property,

i.e., no production is undertaken if inventory is available. A simple dynamic programming algorithm

based on this property runs in O(T 2) time, where T is the number of time periods; this was

improved later to O(T log T ) or linear time for the case in which the costs exclude speculative

motives (for details see Aggarwal and Park (1993), Federgruen and Tzur (1991), and Wagelmans

et al. (1992)). Polynomial time algorithms have also been developed for variants of the deterministic

ULS. A partial list of examples includes an O(T 4) time algorithm for the constant capacity problem

by Florian and Klein (1971) and an improved version that runs in O(T 3) time by van Hoesel and

Wagelmans (1996), an O(T log T ) time algorithm for the uncapacitated problem with backlogging

by Federgruen and Tzur (1993), and a polynomial time algorithm for the uncapacitated problem

with demand time windows by Lee et al. (2001).

In many situations the assumption of known, deterministic data (such as demand) is not neces-

sarily realistic. Recently, Halman et al. (2006) studied a stochastic version of the deterministic ULS

problem in which demand for each time period is uncertain. There are several possible demand

values for each time period with certain probabilities. They showed that the simplest stochastic ver-

sion of the deterministic ULS problem with no setup cost, two possible demand values for each time

period and uncorrelated demand from period to period is NP-complete in T . Thus, they developed

an approximation scheme that is fully polynomial in T and the error term for the problem. Other

2

dynamic programming and approximate dynamic programming approaches for related problems are

explored in Papadaki and Powell (2002, 2003) and Topaloglu and Powell (2006) (among others).

These approaches have proven capable of generating high quality plans for practical problems in

the transportation industry, including multi-commodity transportation planning with integrality

restrictions and batch dispatching problems with setup costs. While these approaches are approx-

imate, the authors have demonstrated that they converge to optimal solutions; and they also seem

to scale well for large problems.

In this paper we investigate a formulation of the stochastic version of the deterministic ULS

which allows demand dependance; in particular, we study the extension of the deterministic ULS in

which a stochastic programming approach (Ruszczynski and Shapiro (2003)) is adopted to address

demand and other uncertain problem parameters. We refer to the resulting model as the stochastic

uncapacitated lot-sizing problem (SULS). The model SULS is the most basic lot-sizing model with

production, setup, and inventory costs that can be stated as a stochastic programming problem.

Thus, investigation of how to solve production planning problems using a scenario tree to model

demand and other parameters should start with the analysis of this model, just as investigation of

how to solve deterministic production planning problems begins with analysis of the deterministic

ULS. Examples of problems that contain submodels of the form SULS embedded within them

include stochastic capacity expansion problems (Ahmed and Sahinidis (2003)), stochastic batch-

sizing problems (Lulli and Sen (2004)), and stochastic production planning problems (Beraldi and

Ruszczynski (2002)).

Since a special case of our problem is shown NP-complete in Halman et al. (2006), it is unlikely

to develop a polynomial time algorithm for the problem in terms of the number of time periods

T . In this paper, we derive a polynomial time algorithm for the problem in terms of input size,

i.e., the number of nodes in the stochastic programming scenario tree. Ahmed et al. (2003) showed

that the Wagner-Whitin optimality conditions do not hold for SULS, which makes it nontrivial to

derive a polynomial time algorithm similar to the deterministic case.

In the remaining part of the paper, we first introduce the notation and a mathematical formu-

lation of SULS in Section 2. Then, in Section 3, we state the production path property for SULS,

a fundamental optimality condition that is analogous to the Wagner-Whitin property for the de-

3

terministic case. We use this property to develop a characterization of the dynamic programming

value function in terms of breakpoints, breakpoint evaluations, and slopes. This property allows us

to show that a full characterization of the optimal value function that contains breakpoint values,

evaluations of breakpoints, and the right slope of each breakpoint can be obtained in O(n3 log C)time, where n is the number of nodes in the scenario tree and C is the maximum number of children

for each node in the tree. In Section 4, we show that these results can be extended to develop

polynomial time algorithms for more generalized tree structures and a couple of special cost struc-

tured SULS. Especially, we show that the optimal solution for the general SULS can be obtained

in O(n2 max{C, log n}) time and the value function for SULS without setup costs is continuous,

piecewise linear and convex, which leads to an O(n2) algorithm. (For the latter case, Huang and

Ahmed (2004, 2005) have presented an O(n2) primal-dual algorithm for a slightly more restricted

version.) We finally offer concluding remarks.

2 Notation and mathematical formulation

In this paper we assume that the uncertain demands and problem parameters evolve as a discrete

time stochastic process with finite probability space. The resulting information structure can be

interpreted as a scenario tree with T levels (stages) as shown in Figure 1, where node i in stage t

Stage TStage 1 Stage 2

i

L

P(i)

Vj V(j)

1

Figure 1: Multi-stage stochastic scenario tree formulation

of the tree gives the state of the system that can be distinguished by information available up to

stage t. Each node i of the scenario tree, except the root node (indexed as i = 1), has a unique

parent a(i). Note that the resulting problem, while highly structured, will no longer be properly

4

called a flow problem (as it is in the deterministic case). The reason is that the same inventory

that “flows” out of a given node i must flow to each of i’s children. Decisions made at node i must

be made before having certain information about how the future unfolds from node i.

Let V(i) represent the set of all descendants of node i (including i itself), L denote the set of

leaf nodes and P(i, `) denote the set of nodes on the path from node i to node `. For notational

brevity, define V = V(1) and P(i) = P(1, i). If i ∈ L, then P(i) corresponds to a scenario and

represents a joint realization of the problem parameters over all periods 1, . . . , T . Let pi denote the

probability associated with the state represented by node i and C(i) denote the children of node i

(i.e., C(i) = {j ∈ V : a(j) = i} and C = maxi∈V{|C(i)|}). Since there are several children explored

from node i, the probability pi =∑

j∈C(i) pj . Finally, let t(i) denote the time stage or level of node

i in the tree (i.e., t(i) = |P(i)|).Using this notation, a multi-stage stochastic MIP formulation of the single-item, uncapacitated,

stochastic lot-sizing problem as shown in Guan et al. (2006b) is

(SULS) : min∑

i∈V(αixi + βiyi + hisi)

s.t. sa(i) + xi = di + si ∀ i ∈ V, (1)

xi ≤ Myi ∀ i ∈ V, (2)

xi, si ≥ 0, yi ∈ {0, 1} ∀ i ∈ V, (3)

where M is a very big number, decision variables xi and si represent the production and the

inventory at the end of time period t(i) corresponding to the state defined by node i, and yi is the

indicator variable for a production setup in time period t(i) for node i. Problem parameters αi, βi,

and hi represent the nonnegative production, setup and holding costs and di represents the demand

in node i. For notational brevity, probability pi is included in problem parameters αi, βi and hi.

Constraint (1) represents the inventory flow balance and constraint (2) indicates the relationship

between production and setup for each node i.

3 A polynomial time algorithm

We develop a polynomial time dynamic programming algorithm to provide a full characterization of

the value function for SULS. To facilitate the development of this algorithm, we first introduce the

5

production path property, which characterizes conditions that at least one optimal solution of every

instance of SULS must satisfy. This will allow us to define a backward recursion for which the value

function of each node i is piecewise linear and right continuous; these value functions can therefore

be analyzed in terms of breakpoints (i.e., discontinuities), functional evaluations of breakpoints,

and the slopes of the segments to the right of the breakpoints. We achieve the complexity bound

by analyzing the number of breakpoints whose evaluations and right slopes must be stored and

computed at each node, and by analyzing how long these computations take. For both of these

calculations the production path property will be essential.

3.1 An optimality condition

Proposition 1 (Production Path Property) For any instance of SULS, there exists an optimal

solution (x∗, y∗, s∗) such that for each node i ∈ V,

if x∗i > 0, then x∗i = dij − s∗a(i) for some j ∈ V(i), (4)

where dij =∑

k∈P(i,j) dk. In other words, there always exists an optimal solution such that if we

produce at a node i, then we produce exactly enough to satisfy demand along the path from node i

to some descendant of node i.

Proof: By contradiction; we will show that any optimal solution that contains a node that violates

(4) is a convex combination of optimal solutions, at least one of which contains one less node that

violates (4).

Assume the claim is not correct. That is, for any optimal solution (x∗, y∗, s∗), there exists some

i ∈ V such that x∗i > 0 and x∗i 6= dij − s∗a(i) for any j ∈ V(i). Let Ψ(i) be those descendants of node

i that are the first nodes with positive production quantities along some path from node i to a leaf

node. That is,

Ψ(i) = ∪`∈L∩V(i) min {k ∈ P(i, `) \ {i} and x∗k > 0} .

Correspondingly, let Φ(i) be the set of nodes in the subpaths from node i to each node in Ψ(i);

that is, Φ(i) = ∪k∈Ψ(i)P(i, k). Define the cost corresponding to the remaining part of the tree as

G(x∗, y∗, s∗) =∑

k∈V\Φ(i)

(αkx∗k + βky

∗k + hks

∗k).

6

Thus the objective function value of the optimal solution (x∗, y∗, s∗) is

F(x∗, y∗, s∗) = G(x∗, y∗, s∗)+αix∗i +βiy

∗i +his

∗i +

∑

k∈Φ(i)\({i}∪Ψ(i))

hks∗k +

∑

k∈Ψ(i)

(αkx∗k +βky

∗k +hks

∗k).

Now consider two alternative solutions (x∗, y∗, s∗) and (x∗, y∗, s∗) such that

• x∗i = x∗i − ε, s∗k = s∗k − ε for each k ∈ Φ(i) \Ψ(i) and x∗k = x∗k + ε for each k ∈ Ψ(i)

• x∗i = x∗i + ε, s∗k = s∗k + ε for each k ∈ Φ(i) \Ψ(i) and x∗k = x∗k − ε for each k ∈ Ψ(i)

and other components are the same as (x∗, y∗, s∗). It is easy to observe that these two solutions

satisfy constraints (1)– (3). Thus, they are feasible for SULS and correspondingly

F(x∗, y∗, s∗) = G(x∗, y∗, s∗) + (αi(x∗i − ε) + βiy∗i + hi(s∗i − ε)) +

∑

k∈Φ(i)\({i}∪Ψ(i))

hk(s∗k − ε)

+∑

k∈Ψ(i)

(αk(x∗k + ε) + βky∗k + hks

∗k)

= F(x∗, y∗, s∗)− αiε−∑

k∈Φ(i)\Ψ(i)

hkε +∑

k∈Ψ(i)

αkε

and

F(x∗, y∗, s∗) = G(x∗, y∗, s∗) + (αi(x∗i + ε) + βiy∗i + hi(s∗i + ε)) +

∑

k∈Φ(i)\({i}∪Ψ(i))

hk(s∗k + ε)

+∑

k∈Ψ(i)

(αk(x∗k − ε) + βky∗k + hks

∗k)

= F(x∗, y∗, s∗) + αiε +∑

k∈Φ(i)\Ψ(i)

hkε−∑

k∈Ψ(i)

αkε.

If αi +∑

k∈Φ(i)\Ψ(i) hk−∑

k∈Ψ(i) αk 6= 0, then min{F(x∗, y∗, s∗),F(x∗, y∗, s∗)} < F(x∗, y∗, s∗), con-

tradicting the assumption that (x∗, y∗, s∗) is an optimal solution. Otherwise, if αi+∑

k∈Φ(i)\Ψ(i) hk−∑

k∈Ψ(i) αk = 0, then ε can be increased such that x∗i = dij − sa(i) or x∗i = dij − sa(i) for some

j ∈ {i} ∪ Ψ(i). Without loss of generality, assume x∗i = dij − sa(i) for some j ∈ {i} ∪ Ψ(i). Then

(x∗, y∗, s∗) is also an optimal solution.

A similar argument can be applied to (x∗, y∗, s∗) if there exists a node k ∈ V such that

x∗k 6= dkj − sa(k) for any j ∈ V(k) and consecutively the following ones. We will eventually ei-

ther obtain a solution (x, y, s) such that xi = dij − sa(i) for some j ∈ V(i) if xi > 0 corresponding

to each node i ∈ V or find a solution with a smaller objective function value, contradicting the

7

original assumption. Therefore, the original conclusion holds. 2

The production path property clearly implies there are n candidates for x1 (the production at

the root node) in an optimal solution and therefore we have immediately

Proposition 2 There exists an algorithm that runs in linear time for the two-period SULS.

3.2 Value functions

For the multi-period SULS, let H(i, s) represent the optimal value function for node i ∈ V when

the inventory left from previous period is s (for notational brevity, use s rather than sa(i) for the

second argument of this function).

There are two options for each node i ∈ V: production and non-production. If production

occurs, then the value function for this node contains 1) setup, production and inventory costs

corresponding to this node and 2) the cost for later periods. We will call this function the production

value function HP(i, s). From the production path property, the production quantity at node i is

xi = dij − s for some j ∈ V(i) such that dij > s. Therefore

HP(i, s) = βi + minj∈V(i):dij>s

αi(dij − s) + hi(dij − di) +

∑

`∈C(i)H(`, dij − di)

. (5)

Otherwise, if non-production option occurs, then the value function for this node contains only 1)

inventory holding costs corresponding to this node and 2) the cost for later periods. We will call

this function the non-production value function HNP(i, s). We only need to define it for the case in

which s ≥ di, and it can be expressed as

HNP(i, s) = hi(s− di) +∑

`∈C(i)H(`, s− di). (6)

For the value function H(i, s) at node i, there are three cases:

(1) If s < di, then setup and production is required. Since s < di ≤ dij for any j ∈ V(i), the

value function can be simplified as

H(i, s) = H1P(i, s) = βi + min

j∈V(i)

αi(dij − s) + hi(dij − di) +

∑

`∈C(i)H(`, dij − di)

. (7)

8

(2) If s ≥ maxj∈V(i) dij , then no setup and production is required since current inventory is

enough to cover the demands of all descendants of node i. The value function for this case

can be defined as

H(i, s) = HNP(i, s) = hi(s− di) +∑

`∈C(i)H(`, s− di). (8)

(3) If di ≤ s < maxj∈V(i) dij , then either production or non-production will occur for node i, and

the backward recursion function can be described as

H(i, s) = min {HP(i, s),HNP(i, s)} . (9)

Let [1], . . . , [|V(i)|] be an ordering of the descendants of node i, including i itself, such that di =

di[1] ≤ di[2] ≤ . . . ≤ di[|V(i)|]. In the remaining part of this section, we study the optimal value

function of a general T period scenario tree case in which there are at least two possible outcomes

for each node in the tree (i.e., C(i) ≥ 2, ∀i ∈ V \ L). We describe an important property after

making two observations.

Observation 1 The summation of piecewise linear and right continuous functions is still a piece-

wise linear and right continuous function.

Observation 2 The minimum of two piecewise linear and right continuous functions is still a

piecewise linear and right continuous function.

Proposition 3 The value function H(i, s) for each node i ∈ V is piecewise linear and right contin-

uous in s. Moreover, for each positive discontinuous point s∗, the value H(i, s∗) ≤ lims→s∗− H(i, s).

Proof: By induction.

Base case: In period T , the value function for each node i is

H(i, s) ={

αi(di − s) + βi if 0 ≤ s < di,hi(s− di) otherwise.

As shown in Figure 2, this value function is piecewise linear and right continuous. Moreover, at

the single discontinuous point s = di, we have H(i, di) ≤ lims→d−iH(i, s).

Inductive step: Assume, for each node i ∈ V such that t(i) ≥ t + 1, the value function H(i, s)

9

0

αidi + βi

−αi

hi

di

H(i, s)

s

Figure 2: Value function H(i, s) for node i at time period T

is piecewise linear and right continuous, and that for each discontinuous point s∗, H(i, s∗) ≤lims→s∗− H(i, s). We prove that the claim holds for all i ∈ V such that t(i) = t.

From (5), we can observe the number of candidate optimal production values for xi decreases as

s increases. For instance, when s < di, all values dij−s for each j ∈ V(i) are candidates. In general,

for the interval di[r−1] ≤ s < di[r] with di[0] = 0, values dij − s for each j = [r], [r + 1], . . . , [|V(i)|]are candidates and accordingly, we can define

HrP(i, s) = βi + min

j∈{[r],...,[|V(i)|]}

αi(dij − s) + hi(dij − di) +

∑

`∈C(i)H(`, dij − di)

. (10)

From (5), we can also observe that for each node i ∈ V, the value functions

βi + αi(dij − s) + hi(dij − di) +∑

`∈C(i)H(`, dij − di)

corresponding to all j ∈ V(i) such that dij > s have the same slope −αi. Therefore, there exists a

set of nodes {[rj ] : 1 ≤ j ≤ K} such that di ≤ di[r1] ≤ di[r2] ≤ . . . ≤ di[rK ] = di[|V(i)|] and each

[rj ] = argmin{k∈V(i):dik>s}

βi + αi(dik − s) + hi(dik − di) +

∑

`∈C(i)H(`, dik − di)

for a range of inventory level s. Accordingly, we have

HrP(i, s) = Hrj

P (i, s) for all rj−1 < r ≤ rj and 1 ≤ j ≤ K with r0 = 0. (11)

Then based on (7), (8), (9) and (11), the value function H(i, s) for each node i can be expressed as

follows:

H(i, s) =

H1

P(i, s), if 0 ≤ s < di;min

{HrjP (i, s),HNP(i, s)

}, if max{di, di[rj−1]} ≤ s < di[rj ], for 1 ≤ j ≤ K;

HNP(i, s), if s ≥ di[|V(i)|].

10

In this formulation, the production value function HrjP (i, s) for each 1 ≤ j ≤ K is a linear

function of s and right continuous. From the induction assumption, the non-production value

function HNP(i, s) is the summation of piecewise linear and right continuous functions, as shown

in (6). From Observation 1, this function is also piecewise linear and right continuous. Thus the

value function H(i, s) is the minimum of two piecewise linear, right continuous functions, and from

Observation 2 it is therefore also piecewise linear and right continuous.

Similarly, since H(`, s∗) ≤ lims→s∗− H(`, s) holds at each discontinuous point s∗ for each

node ` ∈ C(i) and HNP(i, s) is the summation of right continuous functions, we have H(i, s∗) ≤lims→s∗− H(i, s) at each discontinuous point s∗ ofHNP(i, s). Thus, it can be observed thatH(i, s∗) ≤lims→s∗− H(i, s) holds at each discontinuous point s∗ in the intervals max{di, di[rj−1]} ≤ s < di[rj ]

for each 1 ≤ j ≤ K.

At each discontinuous point s = di[rj ], we have from (10) and (6) that

lims→di[rj ]

−HP(i, s) = βi + hi(di[rj ] − di) +

∑

`∈C(i)H(`, di[rj ] − di)

and

HNP(i, di[rj ]) = hi(di[rj ] − di) +∑

`∈C(i)H(`, di[rj ] − di).

Then, due to the fact that βi ≥ 0, we have

lims→di[rj ]

−HP(i, s) ≥ HNP(i, di[rj ]). (12)

If lims→di[rj ]− HNP(i, s) ≤ lims→di[rj ]

− HP(i, s), then

lims→di[rj ]

−H(i, s) = lim

s→di[rj ]−HNP(i, s) ≥ HNP(i, di[rj ]) ≥ H(i, di[rj ])

where the first inequality follows from the induction argument and the second inequality follows

from (9).

Otherwise if lims→di[rj ]− HNP(i, s) > lims→di[rj ]

− HP(i, s), then, based on (12),

lims→di[rj ]

−H(i, s) = lim

s→di[rj ]−HP(i, s) ≥ HNP(i, di[rj ]) ≥ H(i, di[rj ]).

Therefore, the conclusion holds. 2

From the above proof, we can easily obtain the following Corollary.

11

Corollary 1 The non-production value function HNP(i, s) is piecewise linear and right continuous;

and at each positive discontinuous point s∗, the value HNP(i, s∗) ≤ lims→s∗− HNP(i, s).

The value functions H(i, s) are discontinuous. In general the minimum of a discontinuous

function may not exist if the infimum is not actually attained. However, in our case, because the

set up cost is assumed to be nonnegative and the value of the function on the right of each point

of discontinuity is smaller than the limit value on the left as shown in Proposition 3, the minimum

is always achieved. Then, based on the value function H(i, s), we can also observe the following

Proposition (i.e., obtain the optimal initial inventory) as a by-product.

Proposition 4 For each i ∈ V, there exists a minimizer s∗ ≥ 0 of H(i, s), and therefore the value

mins≥0H(i, s) = H(i, s∗) exists.

The claim in Proposition 4 can also be extended to SULS with some negative set up costs βi.

In this case, it suffices to fix yi to 1 in case βi < 0, and to solve SULS by using the positive part of

the set up costs βi for all nodes.

Since the value function H(i, s) for each node i ∈ V is piecewise linear and right continuous,

we can let breakpoints represent the s values such that the value function jumps and/or the slope

changes. The value function H(i, s) can be then computed and stored in terms of breakpoints,

evaluations of breakpoints, and slopes corresponding to breakpoints. Let B(i) represent the set of

breakpoints for the value function H(i, s) at node i. The complexity of the problem depends on

the number of breakpoints.

Proposition 5 The number of breakpoints corresponding to the value function H(i, s) for each

node i ∈ V is bounded by O(|V(i)|2).

Proof: We calculate the number of breakpoints |B(i)| for each node i ∈ V backwards from time

period T to time period 1.

First, as shown in Figure 2, there are two breakpoints for the value function corresponding to

each leaf node. For instance, B(i) = {0, di} and |B(i)| = 2 for each leaf node i at time period T .

Now we calculate the number of breakpoints |B(i)| for each node i ∈ V in terms of three

intervals:

12

For the interval 0 ≤ s < di, from formulation (7), we see that the value function H(i, s) is linear

with slope −αi.

For the interval s ≥ di[|V(i)|], no production is required and equation (8) applies for each node

k ∈ V(i). The value function H(i, s) is thus linear with slope∑

k∈V(i) hk in this interval. Therefore,

the two breakpoints s = 0 and di[|V(i)|] are the only breakpoints forH(i, s) in the intervals 0 ≤ s < di

and s ≥ di[|V(i)|].

For the interval di ≤ s < di[|V(i)|], as shown in Proposition 3, the value function

H(i, s) = min{Hrj

P (i, s),HNP(i, s)}

for each 1 ≤ j ≤ K and max{di, di[rj−1]} ≤ s < di[rj ]. (13)

Now we consider the number of breakpoints generated by HNP(i, s) and HP(i, s), respectively.

Number of breakpoints generated by HNP(i, s): From (6) and the fact that adding piecewise

linear functions does not generate new breakpoints, the number of breakpoints for HNP(i, s) is no

more than the total number of breakpoints generated by H(`, s) for each ` ∈ C(i). Thus, in the

interval di ≤ s < di[|V(i)|], the number of breakpoints for HNP(i, s) is

|BNP(i)| ≤∑

`∈C(i)|B(`)| − 1 (14)

since di[|V(i)|] is a breakpoint in B(`) for some ` ∈ C(i) and not in the interval di ≤ s < di[|V(i)|].

Number of breakpoints generated by HP(i, s): From (10) we see that the value function

HrjP (i, s) is linear in the interval max{di, di[rj−1]} ≤ s < di[rj ]. Therefore, all possible breakpoints

for HP(i, s) in the interval di ≤ s < di[|V(i)|] are di[1], di[2], . . . , di[|V(i)|−1].

Note here each breakpoint di[r], 1 < r ≤ |V(i)| originates from the breakpoint d[r] corresponding

to value function H([r], s) and it evolves as the breakpoint da([r])[r] in BNP(a([r])) and so on the

breakpoint dk[r] in BNP(k) for each node k ∈ P([r]). Then the breakpoint di[r] is in BNP(i) since

i ∈ P([r]). Therefore, all breakpoints for HrjP (i, s) are also breakpoints in BNP(i). We may denote

these breakpoints in BNP(i) as old breakpoints for this iteration.

Now, we consider the number of new breakpoints generated, which is the last step necessary to

characterize the value function H(i, s). First note the following factors:

(1) Breakpoints di[1], di[2], . . . , di[|V(i)|−1] are also breakpoints for HNP(i, s).

(2) The production value function HrjP (i, s) in the interval max{di, di[rj−1]} ≤ s < di[rj ] is linear,

as shown in (10).

13

(3) The non-production value function HNP(i, s) is piecewise linear, as shown in Corollary 1.

Given these three observations, the expression (13) shows that the value function H(i, s) between

two old breakpoints in HNP(i, s) can be viewed as the minimum of two linear functions. Therefore,

between any two old breakpoints, there is at most one new breakpoint. Whether there is a break-

point depends on the evaluations of the two functions at the breakpoints, which can be computed

easily based on previously stored information. Essentially, if one of the two functions dominates

the other between the two old breakpoints, there will not be a new breakpoint. Otherwise there

will be one new breakpoint between two old breakpoints. Therefore, we have that

|B(i)| ≤ 2|BNP(i)|+ 2 (15)

since the number of breakpoints is at most double the size of the old breakpoints in the interval

di ≤ s < di[|V(i)|] and two more breakpoints in the intervals 0 ≤ s < di and s ≥ di[|V(i)|].

Combining (14) and (15), we have that

|B(i)| ≤ 2|BNP(i)|+ 2 ≤ 2∑

`∈C(i)|B(`)|. (16)

Since |B(j)| = 2 = 2|V(j)| for each leaf node j at time period T , we have that

|B(i)| ≤ 2T−t(i)+1|V(i)|.

Since every non-leaf node has at least two children, we have

|V(i)| ≥ 1 + 21 + . . . + 2T−t(i) = 2T−t(i)+1 − 1. (17)

Then, combining (16) and (17), the number of breakpoints

|B(i)| ≤ 2T−t(i)+1|V(i)| ≤ |V(i)|2 + |V(i)|.

Thus, the number of breakpoints is bounded by O(|V(i)|2). 2

3.3 Algorithm analysis

We are now ready to analyze the dynamic programming algorithm, which is a construction of

H(i, s), the value function for each node i ∈ V.

14

Theorem 1 For the case that C(i) ≥ 2 for each i ∈ V \ L, the value functions H(i, s) for all i ∈ Vcan be defined by a dynamic programming algorithm that runs in O(n3 log C) time.

Proof: For each node i ∈ V, the value function H(i, s) is piecewise linear and therefore can

be stored in terms of breakpoint values, evaluations of breakpoints, and the right slope of each

breakpoint. In our approach, breakpoints are stored in a non-decreasing order of their inventory

levels using a Linked-List data structure. We construct the value functions H(i, s) by induction

starting from each leaf node at time period T .

The value function of each leaf node is shown in Figure 2 and it can be stored in terms of two

breakpoints:

(1) two breakpoints: s = 0 and s = di.

(2) the evaluations at these two breakpoints: H(i, 0) = αidi + βi and H(i, di) = 0.

(3) the right slope of each breakpoint: r(i, 0) = −αi and r(i, di) = hi.

For the general case to store the value function H(i, s) for each node i ∈ V, we need to perform the

following several steps:

(1) Generate the list of breakpoints of∑

`∈C(i)H(`, s) in non-decreasing order:

First of all, we notice that, by induction, the O(|V(`)|2) breakpoints in B(`) corresponding to

H(`, s) for each ` ∈ C(i) have already been stored in non-decreasing order of their inventory

levels. In our construction process, the basic idea is to pick the smallest inventory level

breakpoint in⋃

`∈C(i) B(`) and add it to the end of the non-decreasing order breakpoint list

for∑

`∈C(i)H(`, s).

(i) We initially construct a list κ that collects the first breakpoint in B(`) for all ` ∈ C(i).We next sort the |C(i)| breakpoints in κ in non-decreasing order of their inventory levels,

which takes O(|C(i)| log |C(i)|) time.

(ii) We remove the first element, the smallest inventory level breakpoint, in κ and add it

to the end of the non-decreasing order breakpoint list for∑

`∈C(i)H(`, s). Without loss

of generality, denote this breakpoint as node ω∗, the first element in B(`1) for some

node `1 ∈ C(i). Then, node ω∗’s next breakpoint (i.e., node u) in B(`1) becomes the

15

first breakpoint in B(`1). We insert this node (i.e., node u) at the right place in list

κ such that the non-decreasing order still holds in κ. This can be done by binary

search in O(log |C(i)|) time since all existing nodes in κ are in non-decreasing order. We

repeat this process until all breakpoints in∑

`∈C(i)H(`, s) have been generated. It takes

O(|V(i)|2 log |C(i)|) time since the number of breakpoints in∑

`∈C(i)H(`, s) is bounded

by O(|V(i)|2).

(iii) It can be observed that the generated breakpoints for∑

`∈C(i)H(`, s) are in non-decreasing

order. Since O(|C(i)| log |C(i)|) ≤ O(|V(i)|2 log |C(i)|), this entire step can be completed

in O(|V(i)|2 log |C(i)|) time.

(2) Calculate and store∑

`∈C(i)H(`, s): Note here at each breakpoint, only one of the func-

tions in the summation jumps and/or changes slope (duplicated breakpoints are consid-

ered separately). Starting from the initial value∑

`∈C(i)H(`, 0) and the initial right slope∑

`∈C(i) lims→0+∂H(`,s)

∂s , we spend O(1) time to calculate and store each breakpoint, and

therefore this step can be completed in O(|V(i)|2) time, since the number of breakpoints is

bounded by O(|V(i)|2) (from Proposition 5).

(3) Calculate and store the breakpoints, evaluations of breakpoints, and slopes for HNP(i, s):

Recall that HNP(i, s) depends on H(`, s − di) for each ` ∈ C(i). This step can therefore be

completed in O(|V(i)|2) time based on (2), since the number of breakpoints is bounded by

O(|V(i)|2) (from Proposition 5).

(4) Calculate ρ(j) = αidij + hi(dij − di) +∑

`∈C(i)H(`, dij − di) and store it for each j ∈ V(i):

Based on the result in (2), the value of the function∑

`∈C(i)H(`, dij−di) with a given j can be

obtained by binary search in O(log |V(i)|2) time, since the number of breakpoints is bounded

by O(|V(i)|2). Therefore, this entire step can be completed in O(|V(i)| log |V(i)|) time.

(5) Calculate and store the breakpoints, evaluations of breakpoints, and slopes for HP(i, s): The

slope for each piece is fixed (i.e., −αi). Sort ρ(j) in non-decreasing order such that ρ([1]) ≤ρ([2]) ≤ . . . ≤ ρ([|V(i)|]). Following this order, select the node index [r1], [r2], . . . , [rK ],

corresponding to each of the K pieces of the value function HP(i, s). This can be done by

choosing r1 = 1 and [rt] = argminj∈V(i){ρ(j) : dij > di[rt−1]} for all t : 2 ≤ t ≤ K. This step

16

can be completed in O(|V(i)| log |V(i)|) time.

(6) Calculate and store the breakpoints, evaluations of breakpoints, and slopes for H(i, s): Here

we must check each linear piece of HP(i, s) with the corresponding one or several pieces of

HNP(i, s), take the minimum of the two functions based on their slopes and evaluations of

breakpoints, and store the new breakpoints, the evaluations of the new breakpoints and the

slopes for the new pieces. This step can be completed in O(|V(i)|2) time since the number of

breakpoints is bounded by O(|V(i)|2) (from Proposition 5).

The maximum complexity for each step is O(|V(i)|2 log |C(i)|). Since the above operations are re-

quired for each node i ∈ V, the optimal value function for SULS can be obtained and stored in

O(n3 log C) time. 2

If the scenario tree is balanced, for instance, |C(i)| = C for all i ∈ V \L, the algorithm yields an

improved complexity result.

Corollary 2 If C(i) = C ≥ 2 for each i ∈ V \ L, then the value functions H(i, s) for all i ∈ V can

be defined by a dynamic programming algorithm that runs in O(n3) time.

Proof: It can be observed that the number of breakpoints for this case is the same as shown

in Proposition 5. The computational complexity of Steps (2)-(6) is also the same as the unbal-

anced tree case. In Step (1), the calculation in (ii) for the balanced tree case can be completed in

O(C|V(`)|2 log C) ≤ O(|V(i)|2) time, since |V(i)| = C|V(`)| + 1. Therefore, the value function can

be obtained in O(n3) time. 2

3.4 An example

Consider a three period SULS example shown in Figure 3 and the corresponding problem parameters

are shown in Table 1. As described in Figure 2, for time period T , the value functionH(4, s) is right

continuous and piecewise linear with two pieces. For this function, we store the two breakpoints

s = 0 and s = d4 = 15, the evaluations for these two breakpoints H(4, 0) = α4d4 + β4 = 35 and

H(4, 15) = 0, and the slopes for each piece −α4 = −1 and h4 = 1. The value function H(5, s) can

be obtained in the same way. Then the function H(4, s)+H(5, s) can be calculated accordingly and

17

5

4

6

7

1

2

3

Figure 3: An example

Table 1: Problem parameters for the example1 2 3 4 5 6 7

βi 15 18 10 20 10 8 15αi 3 1 4 1 2 3 1hi 0.5 1 0.5 1 2 1 0.5di 10 25 40 15 10 8 13

the results are shown in Figure 4. Note here, the value function H(4, s) +H(5, s) is still piecewise

linear and right continuous and will be used later to calculate H(2, s) for node 2. Similarly, the

value functions H(6, s), H(7, s) and H(6, s) +H(7, s) are shown in Figure 5.

15100

30

20

10

35

−2

2

−1

0 10 15

65

60

40

20

20

−3

35

2530

1

10

25

3

s s

H(4, s)

H(5, s)H(4, s) +H(5, s)

Figure 4: Value functions H(4, s), H(5, s) and H(4, s) +H(5, s)

Then, to obtain the value function H(2, s), we first calculate

ρ(2) = α2d2 +H(4, 0) +H(5, 0) = 90,

ρ(5) = α2d25 + h2(d25 − d2) +H(4, d25 − d2) +H(5, d25 − d2) = 70, and

ρ(4) = α2d24 + h2(d24 − d2) +H(4, d24 − d2) +H(5, d24 − d2) = 65,

where the value H(4, s) +H(5, s) can be obtained from Figure 4 directly. Thus [r1] = [rK ] = 4 and

there is only one piece for the production value function HP(2, s). As shown in Figure 6, the slope

for the production value function HP(2, s) is −α2 = −1 in the interval 0 ≤ s < 40.

18

0 013

32

24

16

8

28

−1

15−3

8

1

0.5

8 8 13

60

40

20

16

−4

28

20 20

5 1.5

16

H(7, s)

H(6, s)

H(6, s) +H(7, s)

s s

Figure 5: Value functions H(6, s), H(7, s) and H(6, s) +H(7, s)

The non-production value function HNP(2, s) can be described easily by moving the function

H(4, s)+H(5, s) introduced in Figure 4 to the right by d2 = 25 and increasing the slope by h2 = 1.

It is shown in Figure 6 the three pieces in the intervals 25 ≤ s < 35, 35 ≤ s < 40 and s ≥ 40.

Then the value function H(2, s) is the minimum of two value functions HP(2, s) and HNP(2, s) as

shown the solid line in the Figure. In this case, two new breakpoints are generated in the intervals

25 ≤ s < 35 and 35 ≤ s < 40 respectively during the minimization operation.

The value function H(3, s) can be calculated in a similar way. In this case, there are two pieces

for HP(3, s) and only one new breakpoint generated as shown in Figure 6.

Finally, for the value function expression of H(1, s), we only calculate H(1, 0). We have

ρ(1) = α1d1 +H(2, 0) +H(3, 0) = 339,

ρ(2) = α1d12 + h1(d12 − d1) +H(2, d12 − d1) +H(3, d12 − d1) = 301.5,

ρ(3) = ρ(4) = α1d14 + h1(d14 − d1) +H(2, d14 − d1) +H(3, d14 − d1) = 255,

ρ(5) = α1d15 + h1(d15 − d1) +H(2, d15 − d1) +H(3, d15 − d1) = 273.6,

ρ(6) = α1d16 + h1(d16 − d1) +H(2, d16 − d1) +H(3, d16 − d1) = 273,

ρ(7) = α1d17 + h1(d17 − d1) +H(2, d17 − d1) +H(3, d17 − d1) = 304,

where ρ(3) = ρ(4) holds due to the fact that d13 = d14. Then, following (7), we obtain the

optimal objective value for this problem with zero initial inventory H(1, 0) = HP(1, 0) = β1 +

mink∈V(1) ρ(k) = 15 + 255 = 270.

19

0 025 35 40

20

40

60

8083

−1

65

58 −2−1

2

−145

48

35

25

445

43

200

150

100

50

603015

226

5340 48

−4

−3.5

66

60

2432

21.5

−4

11.52

H(2, s)

ss

H(3, s)

Figure 6: Value functions H(2, s) and H(3, s)

4 Extensions

In the previous section, we derived a polynomial time algorithm for the full characterization of

H(i, s) in which C(i) ≥ 2 for each i ∈ V \ L. Since the full characterization of H(i, s) contains

breakpoint values, evaluations of breakpoints, and the right slope of each breakpoint, it can provide

insights of the problem that include sensitivity analysis at any inventory level for each node i ∈ V.

It is not known if a polynomial time algorithm exists for deriving the full characterization of H(i, s)

for the cases in which C(i) may be equal 1 for some i ∈ V \ L. In this section, we extend our

analysis to the cases that allow C(i) = 1 for some i ∈ V \L. In one direction, we derive polynomial

time algorithms to solve the more general case to obtain the optimal solution instead of fully

characterizing the value function H(i, s) for each i ∈ V. For instance, the general SULS case in

Section 4.1 and the two-stage case in Section 4.2. In the other direction, we study the polynomial

time algorithms to provide the full characterization of H(i, s) for the more general case under

certain cost restrictions. For instance, SULS without speculative motives in Section 4.3 and SULS

without setup costs in Section 4.4.

4.1 The general SULS

In this section, we consider the general SULS problem (i.e., C(i) ≥ 1 for each node i ∈ V \ L). For

this case, it is not known if the full characterization of the value function H(i, s) for each i ∈ Vcan be obtained in polynomial time. However, an optimal solution of the general SULS can be

obtained in polynomial time. Without loss of generality, we assume zero initial inventory. We also

notice that the general SULS problem for which the initial inventory level is unknown and is itself a

20

decision variable can be transformed into another general SULS problem with zero initial inventory

by adding a dummy root node 0 as the parent node of node 1 with zero production, setup and

inventory costs as well as zero demand.

Theorem 2 The general SULS can be solved in O(n2 max{C, log n}) time.

Proof: With zero initial inventory, according to Proposition 1, we have x1 = d1j and s1 = d1j − d1

for some j ∈ V in an optimal solution. Then, corresponding to the value function H(`, s) for each

` ∈ C(1), we only need to store the breakpoints s = d1j − d1 for all j ∈ V and their evaluations.

In general, based on (8) and (9), the breakpoints for the value function H(i, s) are obtained by

moving the breakpoints for the value function H(`, s) for all ` ∈ C(i) to the right by di plus new

breakpoints generated by minimizing two piecewise linear functions. Thus, in order to store the

breakpoints s = d1j − d1a(i) for all j ∈ V : d1j − d1a(i) ≥ 0 for node i, in the calculation of the value

functions H(`, s) for all ` ∈ C(i), we only need to store the breakpoints s = d1j − d1i = d1j − d1a(`)

for all j ∈ V : d1j − d1a(`) ≥ 0. Therefore, in the algorithm of Theorem 1 to calculate the value

function H(i, s) for each node i ∈ V backwards starting from leaf nodes, we store the breakpoints

s = d1j − d1a(i) for all j ∈ V : d1j − d1a(i) ≥ 0 and their evaluations. There are at most O(n)

breakpoints for each value function H(i, s).

This reduction in the number of breakpoints means that, at each step calculating the value

function H(i, s), we can bound the time the algorithm will take as follows:

• Step (1): Since we have stored the same set of O(n) breakpoints s = d1j − d1a(`) = d1j − d1i

for all j ∈ V : d1j − d1a(`) ≥ 0 corresponding to each value function H(`, s), ` ∈ C(i), the list

of breakpoints of∑

`∈C(i)H(`, s) has the same set of O(n) breakpoints. This step takes O(n)

time;

• Step (2): Based on (1), we have the same set of O(n) breakpoints for each H(`, s), ` ∈ C(i) as

well as∑

`∈C(i)H(`, s). This step takes O(Cn) time since the maximum number of children

is C;

• Step (3): Based on (2), this step can be completed in O(n) time since the number of break-

points is bounded by O(n);

21

• Step (4): Based on (2), the function values∑

`∈C(i)H(`, dij − di) for each j ∈ V are stored in∑

`∈C(i)H(`, s) since dij − di = d1j − d1i = d1j − d1a(`) for each ` ∈ C(i). There are |V(i)| ≤ n

candidates for ρ(k) and the value of each ρ(k) can be obtained by binary search in O(log n)

time since the number of breakpoints is bounded by O(n). Therefore, this entire step can be

completed in O(n log n) time;

• Step (5): This step can be completed in O(n log n) time since the number of breakpoints is

bounded by O(n);

• Step (6): To calculate and store the breakpoints of H(i, s), we have H(i, s) = HP(i, s) for

the breakpoints s = d1j − d1a(i) for each j ∈ V such that d1a(i) ≤ d1j < d1i and H(i, s) =

min{HP(i, s),HNP(i, s)} for the breakpoints s = d1j−d1a(i) for each j ∈ V such that d1j ≥ d1i.

To obtain the minimum in this expression, we compare each linear piece of the production

value function HP(i, s) with several breakpoint values of the corresponding non-production

value function. This step can be completed in O(n) time since the number of breakpoints is

bounded by O(n).

Therefore, the total amount of work required at each node is bounded by O(nmax{C, log n}). The

result follows by multiplying this by the number of nodes. 2

4.2 The two-stage SULS

For a T period planning problem, a two-stage SULS has known demands for the first t periods,

which are usually considered as defining the first-stage problem. The uncertainty for the second-

stage is explored in time period t+1. Demands for time periods t+1 to T perform as a deterministic

case corresponding to each scenario explored in time period t + 1. For instance, assuming there

are K scenarios explored in time period t + 1, we have C(i) = K if t(i) = t and C(i) = 1 for other

non-leaf nodes.

Proposition 6 The two-stage SULS can be solved in O(n2 log n) time.

Proof: From Proposition 1, assuming t(i∗) = t, we have si∗ = di∗k − di∗ for some k ∈ V(i∗) in

the optimal solution, which contains K(T − t) + 1 ≤ n candidates. Corresponding to each candi-

22

date, the first t period problem is a deterministic ULS with a given final inventory level, which is

equivalent to another ULS without final inventory by updating the demand at time period t. Thus,

the optimal solution can be obtained in O(n log n) time as studied by Aggarwal and Park (1993).

Similarly, the second T − t period problem corresponding to each scenario is a deterministic ULS

with a given initial inventory level. Thus, the optimal solution for the second-stage problems can

be obtained in O(K(T − t) log(T − t)) ≤ O(n log n) time. Finally, the minimum value among all

candidates can be achieved in O(n2 log n) time and the conclusion holds. 2

4.3 SULS without speculative motives

For the deterministic ULS, researchers and practitioners have long recognized that, in many sit-

uations, the costs will never encourage us to produce before we have to. For instance, If we are

planning to set up in time periods both t and t + 1, it will never be cheaper to produce in period

t to satisfy demand in t + 1 than it is to produce in period t + 1 to satisfy demand in t + 1. Cost

structures satisfying this condition are referred to as without speculative motives orWagner-Whitin

costs in the literature (see Wagelmans et al. (1992) and Pochet and Wolsey (1994, 2006), among

others).

We consider a similar cost structure for SULS. Assume that

for each i ∈ V \ L, αi + hi ≥∑

j∈C(i)αj and βi ≥

∑

j∈C(i)βj . (18)

This condition states that the sum of the unit production and inventory holding costs at node

i is not less than the sum of unit production costs of its children. It also states that the setup

cost βi at node i is not less than the sum of setup costs of its children. Thus, we need never

consider producing at a node i if the inventory entering i is sufficient to satisfy the demand at i

(i.e., if sa(i) ≥ di) since we can set up and produce at each node j ∈ C(i) instead of node i with a

non-larger cost.

For this case we can show that our algorithm runs faster than in the general case described

in Section 3. In terms of the value functions of Section 3, (18) implies that we can assume that

H(i, s) = HP(i, s) if and only if 0 ≤ s < di, and that H(i, s) = HNP(i, s) if s ≥ di. Because of this,

there will never be new breakpoints at node i that occur between old breakpoints defined by the

23

value functions H(`, s), ` ∈ C(i). Therefore the number of breakpoints required to define the value

function H(i, s) will be O(|V(i)|), for every i ∈ V.

In terms of the algorithm of Theorem 1, this reduction in the number of breakpoints means

that we can bound the time that each step will take as follows:

• Step (1) is not needed since the breakpoints can be pre-determined and they correspond to

each node k ∈ V(i);

• Step (2) now takes O(|V(i)|) time;

• Step (3) now takes O(|V(i)|) time;

• Step (4) now takes O(|V(i)|) time since there are only |V(i)| candidates corresponding to

|V(i)| breakpoints;

• Step (5) can now be done in O(|V(i)|) time, since we are now only interested in the choice of

k that minimizes ρ(k);

• Step (6) now takes O(|V(i)|) time, and consists simply of setting H(i, s) = HP(i, s) if 0 ≤ s <

di, and H(i, s) = HNP(i, s) if s ≥ di.

We can now state

Proposition 7 Without speculative motives, the value functions H(i, s), i ∈ V, can be defined by

a dynamic programming algorithm that runs in O(n2) time.

Proof: From the above argument, the total amount of work done at each node is bounded by

O(|V(i)|) = O(n). The result follows by multiplying this by the number of nodes. 2

4.4 SULS without setup costs

As described in Zipkin (2000), in many applications setup costs can be neglected in production

planning. The deterministic version in this case is easily solved by using a greedy algorithm de-

scribed in Johnson (1957). In this case the formulation of the stochastic problem (which we call

24

SULS-W) simplifies to

(SULS-W) : min∑

i∈V(αixi + hisi)

s.t. sa(i) + xi = di + si ∀ i ∈ V,

xi, si ≥ 0 ∀ i ∈ V.

Primal and dual algorithms with complexity O(n2) have been developed recently in Huang and

Ahmed (2004, 2005) for the special case of this model in which the tree is balanced with zero initial

inventory. In this section, we provide the full characterization of the optimal value function for a

general tree structure (i.e., C(i) ≥ 1 for each i ∈ V \L). The optimal value function can be obtained

in O(n2) time.

As will be seen in the development of this section, this analysis relies on the fact that the value

function H(i, s) for SULS-W is not only piecewise linear but also convex. For brevity, we remind

the reader here that any function that is convex must also necessarily be continuous (we will omit

stating that the value functions are continuous in the development of this section). This is the

primary advantage that the absence of setups allows us to exploit in our analysis: Not only do the

value functions become continuous (recall that, for SULS, this is not true in general), but they are

also convex. This, along with the production path property, allows us to show that the number of

breakpoints of H(i, s) is an order of magnitude smaller at each node i than for SULS, yielding the

improved complexity result.

We write the value function for SULS-W in a slightly different way. For the non-production

case we have

HNP(i, s) = hi(s− di) +∑

`∈C(i)H(`, s− di). (19)

Since the production path property still holds and no setup cost, the production value function can

be written as

HrP(i, s) = min

k∈{[r],...,[|V(i)|]}

αi(dik − s) + hi(dik − di) +

∑

`∈C(i)H(`, dik − di)

(20)

in the interval di[r−1] ≤ s < di[r], for r = 1, . . . , |V(i)| with di[0] = 0. Similar as the case

with setup costs, there are several production value function pieces ending with breakpoints s =

25

di[r1], di[r2], . . . , di[rK ] such that di = di[1] ≤ di[r1] ≤ . . . ≤ di[rK ] = di[|V(i)|] and

HrP(i, s) = Hrj

P (i, s) for all rj−1 < r ≤ rj and 1 ≤ j ≤ K with r0 = 0.

Then,

H(i, s) =

H1

P(i, s), if 0 ≤ s < di;min

{HrjP (i, s),HNP(i, s)

}, if max{di, di[rj−1]} ≤ s < di[rj ], for 1 ≤ j ≤ K;

HNP(i, s), if s ≥ di[|V(i)|].

We can observe from (20) that

HrjP (i, s) = αi(di[rj ] − s) + hi(di[rj ] − di) +

∑

`∈C(i)H(`, di[rj ] − di).

Thus, we have

HrjP (i, di[rj ]) = HNP(i, di[rj ]) for each 1 ≤ j ≤ K. (21)

Before we prove that the value function H(i, s) is piecewise linear and convex, we define

[r∗] = [r1] = argmink∈{[1],...,[|V(i)|]}

αidik + hi(dik − di) +

∑

`∈C(i)H(`, dik − di)

(22)

and introduce an important Lemma.

Lemma 1 If HNP(i, s) as defined in (19) is piecewise linear and convex, and contains |V(i)| break-points s = di[1], . . . , di[|V(i)|], then −αi ≤ lims→d+

i[r∗]∂HNP(i,s)

∂s and lims→d−i[r∗]

∂HNP(i,s)∂s ≤ −αi if

r∗ > 1.

Proof: We first show −αi ≤ lims→d+i[r∗]

∂HNP(i,s)∂s .

Let H1(i, s) = αi(di[r∗+1]− s) + hi(di[r∗+1]− di) +∑

`∈C(i)H(`, di[r∗+1]− di) and we can observe

that

H1(i, di[r∗+1]) = HNP(i, di[r∗+1]) = HNP(i, di[r∗]) + lims→d+

i[r∗]

∂HNP(i, s)∂s

(di[r∗+1] − di[r∗]), (23)

where the second equation follows from the fact that s = di[r∗] and s = di[r∗+1] are two consecutive

breakpoints of a piecewise linear and convex function HNP(i, s).

We can also observe that, according to the definition of HrP(i, s) shown in (20) and r∗ shown

in (22),

Hr∗P (i, di[r∗+1]) = Hr∗

P (i, di[r∗])− αi(di[r∗+1] − di[r∗]) (24)

26

and

Hr∗P (i, di[r∗+1]) ≤ H1(i, di[r∗+1]). (25)

Then, comparing (23) and (24), we have−αi ≤ lims→d+i[r∗]

∂HNP(i,s)∂s sinceHr∗

P (i, di[r∗]) = HNP(i, di[r∗])

based on (21) and Hr∗P (i, di[r∗+1]) ≤ H1(i, di[r∗+1]) as shown in (25).

Similarly, to prove lims→d−i[r∗]

∂HNP(i,s)∂s ≤ −αi for the case r∗ > 1, define

H2(i, s) = αi(di[r∗−1] − s) + hi(di[r∗−1] − di) +∑

`∈C(i)H(`, di[r∗−1] − di).

We have

Hr∗P (i, di[r∗−1]) = Hr∗

P (i, di[r∗]) + αi(di[r∗] − di[r∗−1]) (26)

and

HNP(i, di[r∗−1]) = HNP(i, di[r∗])− lims→d−

i[r∗]

∂HNP(i, s)∂s

(di[r∗] − di[r∗−1]). (27)

Then, comparing (26) and (27), we have lims→d−i[r∗]

∂HNP(i,s)∂s ≤ −αi since HNP(i, di[r∗−1]) =

H2(i, di[r∗−1]) ≥ Hr∗P (i, di[r∗−1]) and Hr∗

P (i, di[r∗]) = HNP(i, di[r∗]).

Therefore the conclusion holds. 2

Proposition 8 The value function H(i, s) is a piecewise linear and convex function of s. Moreover,

there are |V(i)| nonzero breakpoints: s = di, di[2], . . . , and di[|V(i)|].

Proof: By induction.

Base case: For the time period t = T , the value function for a node i is shown in Figure 7, which

is a piecewise linear and convex function with breakpoints s = di and s = 0.

Inductive step: Assume the claim is true for each function H(i, s) : t ≤ t(i) ≤ T . Now we prove

that, for each node i : t(i) = t− 1, the value function H(i, s) is piecewise linear and convex, and it

has |V(i)| nonzero breakpoints. We derive this conclusion from the following main steps:

(i) Non-production value function HNP(i, s): From the induction assumption, the value function

H(`, s) is piecewise linear and convex for each ` ∈ C(i) containing |V(`)| nonzero breakpoints.

Then, the non-production value function HNP(i, s) defined in (19) is piecewise linear and

convex since it is the summation of piecewise linear and convex functions. It is easy to verify

27

that it contains at most∑

`∈C(i) |V(`)|+1 = |V(i)| breakpoints, which are s = di[1], . . . , di[|V(i)|].

Details are shown in Figure 8, where the function is shown as the dotted line in the interval

0 ≤ s ≤ di[r∗] and the solid line in the interval di[r∗] ≤ s.

(ii) Production value function HP(i, s): As shown in the analysis for the cases with setup costs,

the production value function HP(i, s) is piecewise linear and discontinuous with the same

slope −αi in the intervals ending with breakpoints s = di[r1], di[r2], . . . , di[rK ] with r1 = r∗ as

defined in (22). Details are shown in Figure 8, where the function is shown as the solid line

in the interval 0 ≤ s ≤ di[r∗] and the dotted lines in the interval di[r∗] ≤ s ≤ di[|V(i)|].

(iii) Value function H(i, s): We compare HP(i, s) and HNP(i, s). First, we have

Hr∗P (i, di[r∗]) = HNP(i, di[r∗]) (28)

according to (21) and

lims→d+

i[r]

∂HNP(i, s)∂s

is non-decreasing as r increases (29)

since HNP(i, s) analyzed in (i) is piecewise linear and convex. Note that HNP(i, s) satisfies the

assumption in Lemma 1, we have

−αi ≤ lims→d+

i[r∗]

∂HNP(i, s)∂s

and lims→d−

i[r∗]

∂HNP(i, s)∂s

≤ −αi if r∗ > 1. (30)

Then, combining (28), (29) and (30), HNP(i, s) ≤ HP(i, s) in the interval s < di[r∗]. In the

interval s ≥ di[r∗], we have HrjP (i, di[rj ]) = HNP(i, di[rj ]) for each 2 ≤ j ≤ K according to (21)

and lims→d+i[r]

∂HNP(i,s)∂s ≥ −αi for each r ≥ r∗ due to (29) and (30). Then, HNP(i, s) ≤ HP(i, s)

in the interval s ≥ di[r∗].

Therefore, we have

H(i, s) ={ HP(i, s), if 0 ≤ s < di[r∗];HNP(i, s), otherwise.

That is, H(i, s) is a piecewise linear and convex function with the nonzero breakpoints s =

di[r∗], di[r∗+1], . . . , di[|V(i)|] as shown with the solid line in Figure 8. 2

Theorem 3 Without setup costs, the value functions H(i, s), i ∈ V, can be defined by a dynamic

programming algorithm that runs in O(n2) time.

28

0

−αi

H(i, s)

αidi

sdi

hi

Figure 7: Value function H(i, s) for node i at time period T

0

HNP(i, s)

H(i, s)

sdi di[|V(i)|]di[r∗]

Hr∗P

(i, s)Hrj

P (i, s)

Figure 8: Value function H(i, s)

Proof: The value function can be obtained by the following briefly described steps:

(1) Initialization: First, we calculate d1i for each i ∈ V and sort them in non-decreasing order

(i.e., s0 = d1[1], . . . , d1[n]). These are enough to serve as the breakpoints of the value function

H(i, s) for each node i ∈ V. For instance, corresponding to each node i ∈ V, we set s = 0 at

the breakpoint s0 = d1a(i) and H(i, s) can be stored at the breakpoints corresponding to each

node k ∈ V : d1k ≥ d1a(i). Second, for each node i ∈ V, we set correspondence between node

i and each node k ∈ V(i). This entire step can be completed in O(n2) time.

(2) Store the value function H(i, s) for each node i ∈ V: This can be done backwards starting

from time period T . For each H(`, s), ` ∈ L, we set s = 0 at the breakpoint s0 = d1a(`). Then,

each value function H(`, s), ` ∈ L can be represented by storing the evaluation at s = 0 and

the right slope for each point s = d1k − d1a(`) for each k ∈ V and d1k ≥ d1a(`). That is, this is

stored at the breakpoints s0 = d1k for each k ∈ V such that d1k ≥ d1a(`). The following steps

29

are required corresponding to each node i ∈ V \ L:

(i) Calculate and store∑

`∈C(i)H(`, s): We set s = 0 at the breakpoint s0 = d1i, which is the

same as s0 = d1a(`) for each ` ∈ C(i). By induction, the value function H(`, s) for each

` ∈ C(i) is convex, piecewise linear and stored at the points s = d1k−d1a(`) for each k ∈ Vand d1k ≥ d1a(`) (i.e., at the breakpoints s0 = d1k for each k ∈ V such that d1k ≥ d1a(`) =

d1i). Then, the value function∑

`∈C(i)H(`, s) is continuous and piecewise linear. It can

be stored in terms of initial value∑

`∈C(i)H(`, 0) and the right slopes at breakpoints

k ∈ V : d1k ≥ d1i. Following the order defined in (1). We initialize the right slope

value to be∑

`∈C(i) lims→0+∂H(`,s)

∂s . At each breakpoint k, based on the correspondence

information set up in (1), if k ∈ V(`) for some ` ∈ C(i), the right slope at this breakpoint

for∑

`∈C(i)H(`, s) will be increased by lims→(d1k−d1i)+∂H(`,s)

∂s − lims→(d1k−d1i)−∂H(`,s)

∂s

from the right slope of the previous breakpoint. Otherwise, the right slope for this

breakpoint is kept the same as the right slope of the previous breakpoint. At each

breakpoint, we consider at most one value function H(`, s) among all ` ∈ C(i) in which

the slope changes (duplicated breakpoints are considered separately). Therefore, this

step can be completed in O(n) time.

(ii) Calculate∑

`∈C(i)H(`, dik − di) for each node k ∈ V : d1k ≥ d1i and HNP(i, s) shown

in (19): Based on (i), this can be completed in O(n) time.

(iii) Calculate [r∗] defined in (22): Since∑

`∈C(i)H(`, dik − di) for each k ∈ V(i) has been

calculated in (ii), this step can be completed by binary search in O(log n) time.

(iv) Obtain H(i, s): Update HNP(i, s) to HP(i, s) in the interval 0 ≤ s ≤ di[r∗] that includes

the slopes of the breakpoints within this interval and the evaluation of the breakpoint

s = 0. This step can be completed in O(n) time.

Therefore, an optimal value function can be obtained in O(n2) time. 2

4.5 Example (continued)

In this section, we consider an example with the same data as the one mentioned in section 3.4,

except for the absence of setup costs.

30

We first consider leaf node 4 at time period 3. The value function H(4, s) is continuous and

piecewise linear with two pieces as described in Figure 7. The slopes for the two pieces are −1 and

1, which correspond to −α4 and h4 respectively. There is one nonzero breakpoint s = d4 = 15. The

slopes and the breakpoint for the value function H(5, s) can be obtained in a similar way. Then,

the function H(4, s) + H(5, s) can be calculated accordingly, which will be used later to describe

HNP(2, s). The details are shown in Figure 9. The same operations can be applied to leaf nodes 6

and 7 and the details are shown in Figure 10.

20

15

−2

0 10 15

1

2

−1 10

35

5

−3

1

3

10 150

H(5, s)

H(4, s) H(4, s) +H(5, s)

s s

Figure 9: Value functions H(4, s), H(5, s) and H(4, s) +H(5, s)

37

−4

1.5

5

8 13

24

13 −3

1

−1

0.5

8 13 00

H(6, s)

H(7, s)

H(6, s) +H(7, s)

ss

Figure 10: Value functions H(6, s), H(7, s) and H(6, s) +H(7, s)

Then, consider the value function H(2, s). The non-production value function HNP(2, s) can be

described easily by moving the function H(4, s)+H(5, s) to the right by d2 = 25 and increasing the

31

slope by h2 = 1. It is shown in Figure 11 with the dotted line in the interval 25 ≤ s ≤ 35 and with

the solid line in the interval s ≥ 35. The production value function HP(2, s) contains two pieces

as shown with the solid line in the interval 0 ≤ s ≤ 35 and with the dotted line in the interval

35 ≤ s ≤ 40. Note here we only need to consider the first piece. Following (22),

[r∗] = argmink∈{2,5,4}

α2d2k + h2(d2k − d2) +

∑

`∈C(2)

H(`, d2k − d2)

= argmin {25 + 0 + 35, 35 + 10 + 10, 40 + 15 + 10}

= 5.

Therefore,

H(2, s) ={ HP(2, s), if 0 ≤ s ≤ d25 = 35;HNP(2, s), Otherwise

as shown with the solid line in Figure 11.

The same logic applies to calculating the value function H(3, s) and the only difference is that

[r∗] = 3 for this case, which leads to the case that no intervals in HNP(3, s) are updated to HP(3, s).

Finally, we can perform a procedure similar to that described above to calculate the value

function H(1, s). In this iteration, [r∗] = 5 and the corresponding value function H(1, s) as well as

H(2, s) +H(3, s) are shown in Figure 12.

197

0

−4

−4

−3.5

40 48

−4

0.5530

−1

25

−22

4

35 40

2

35

30

25

15

30

50

1541

31.5

11.59

4030

10

s

H(3, s)

s

H(2, s)

Figure 11: Value functions H(2, s) and H(3, s)

5 Conclusions

In this paper, we first studied that the value function H(i, s) for each i ∈ V for SULS is piecewise

linear and right continuous. Correspondingly, for the case C(i) ≥ 2 for each i ∈ V \L, we developed

32

0 35 4840 53

6

0.5

−5

72

−2 6266

88.5

4.5

0

247

45 50 58 6310

247

−4.5

6.5

5

1−1.5

−3

224.5

89.582

90

115

90

60

115

80

ss

H(2, s) +H(3, s) H(1, s)

Figure 12: Value functions H(2, s) +H(3, s) and H(1, s)

a polynomial time algorithm that runs in O(n3 log C) time for obtaining the full characterization

of the value function, which was further improved to be O(n3) time for the balanced tree case

(i.e., C(i) = C,∀i ∈ V \ L). Then, we extended our analysis to a more general tree structure.

For instance, there are several nodes i ∈ V \ L such that C(i) = 1. In this case, the number of

nodes in the tree can be polynomial to the number of time periods. We studied this more general

tree structure in two categories. For the first category, we developed polynomial time algorithms

for SULS to obtain the optimal solutions. It includes a polynomial time algorithm that runs in

O(n2 max{C, log n}) time for the general tree case and a polynomial time algorithm that runs in

O(n2 log n) time for the two-stage SULS. For the second category, we developed polynomial time

algorithms that run in O(n2) time to obtain the full characterization of the value functions for two

special cases: SULS without speculative motives and SULS without setup costs. Since SULS is a

fundamental stochastic integer programming structure, our studies on SULS and its variants will

help solve many large complicated stochastic integer programming problems.

Valid inequalities for SULS and its variant with constant production capacities have been pro-

posed in Guan et al. (2006b) and Summa and Wolsey (2006). These papers demonstrate compu-

tationally that these inequalities form very tight approximations of the convex hull. Moreover, in

Guan et al. (2006a) it is shown that they define the convex hull of SULS with two periods; but

this is not true for the general case of SULS. Thus, an interesting open question is the definition

of a complete description of the convex hull of SULS (either explicit—by valid inequalities—or

implicit—by extended formulation). This seems to be difficult. While one can transform the dy-

namic programming approach presented here into a linear programming formulation, we have not

33

yet been able to do this in such a way that the variables in this LP formulation relate to the x, y,

and s variables. (This is in contrast to the deterministic case, in which, for example, the shortest

path reformulation of Eppen and Martin (1987) is directly related to the dynamic programming

approach of Wagner and Whitin).

It is shown in Bitran and Yanasse (1982) that the singe item deterministic capacitated lot-sizing

problem (CLSP) is NP-hard. This implies that the stochastic CLSP with the general tree structure

(i.e., C(i) ≥ 1 for each i ∈ V) is NP-hard, since the deterministic CLSP is a special case of this

problem containing only one scenario. However, the deterministic problem with constant capacity is

polynomial time solvable, and it may be possible to solve the stochastic version in polynomial time,

also. This is an area of future research. In the future we also intend to combine our approaches,

polynomial time algorithms and polyhedral studies, into decomposition frameworks for large size

stochastic integer programming problems, such as those studied by Carøe (1998) and Sen and

Sherali (2006) (among others).

Acknowledgments

The authors thank the associate editor and the referees for their detailed and helpful comments.

Support of this research has been provided by Oklahoma Transportation Center and National

Science Foundation under Award CMMI-0700868 for the first author and by the Air Force Office of

Scientific Research under Award FA9550-04-1-0192 and National Science Foundation under Award

DMI-0323299 for the second author.

References

Aggarwal, A., J. K. Park. 1993. Improved algorithms for economic lot size problems. Operations

Research 41 549–571.

Ahmed, S., A. J. King, G. Parija. 2003. A multi-stage stochastic integer programming approach

for capacity expansion under uncertainty. Journal of Global Optimization 26 3–24.

Ahmed, S., N. V. Sahinidis. 2003. An approximation scheme for stochastic integer programs arising

in capacity expansion. Operations Research 51 461–471.

34

Belvaux, G., L. A. Wolsey. 2000. bc − prod: a specialized branch–and–cut system for lot-sizing

problems. Management Science 46 724–738.

Belvaux, G., L. A. Wolsey. 2001. Modelling practical lot–sizing problems as mixed integer programs.

Management Science 47 993–1007.

Beraldi, P., A. Ruszczynski. 2002. A branch and bound method for stochastic integer problems

under probabilistic constraints. Optimization Methods and Software 17 359–382.

Bitran, G. R., H. H. Yanasse. 1982. Computational-complexity of the capacitated lot size problem.

Management Science 28 1174–1186.

Carøe, C. C. 1998. Decomposition in stochastic integer programming. Ph.D. thesis, University of

Copenhagen.

Eppen, G. D., R. K. Martin. 1987. Solving multi–item lot–sizing problems using variable redefini-

tion. Operations Research 35 832–848.

Federgruen, A., M. Tzur. 1991. 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 909–925.

Federgruen, A., M. Tzur. 1993. The dynamic lot-sizing model with backlogging-a simple O(n log n)

algorithm and minimal forecast horizon procedure. Naval Research Logistics 40 459–478.

Florian, M., M. Klein. 1971. Deterministic production planning with concave costs and capacity

constraints. Management Science 18 12–20.

Guan, Y., S. Ahmed, A. J. Miller, G. L. Nemhauser. 2006a. On formulations of the stochastic

uncapacitated lot-sizing problem. Operations Research Letters 34 241–250.

Guan, Y., S. Ahmed, G. L. Nemhauser, A. J. Miller. 2006b. A branch-and-cut algorithm for the

stochastic uncapacitated lot-sizing problem. Mathematical Programming 105 55–84.

Halman, N., D. Klabjan, M. Mostagir, J. Orlin, D. Simchi-Levi. 2006. A fully polynomial time

approximation scheme for single-item stochastic lot-sizing problems with discrete demand. Tech.

rep., MIT.

35

Huang, K., S. Ahmed. 2004. On a stochastic programming model for inventory planning. Tech.

rep., Georgia Institute of Technology.

Huang, K., S. Ahmed. 2005. The value of multi-stage stochastic programming in capacity planning

under uncertainty. Tech. rep., Georgia Institute of Technology.

Johnson, S. M. 1957. Sequential production planning over time at minimum cost. Management

Science 3 435–437.

Lee, C. Y., S. Cetinkaya, A. Wagelmans. 2001. A dynamic lot-sizing model with demand time

windows. Management Science 47 1384–1395.

Lulli, G., S. Sen. 2004. A branch-and-price algorithm for multi-stage stochastic integer programming

with application to stochastic batch-sizing problems. Management Science 50 786–796.

Nemhauser, G. L., L. A. Wolsey. 1988. Integer and Combinatorial Optimization. Wiley, New York.

Papadaki, K., W. B. Powell. 2002. Exploiting structure in adaptive dynamic programming algo-

rithms for a stochastic batch service problem. European Journal of Operational Research 142

108–127.

Papadaki, K., W. B. Powell. 2003. An adaptive dynamic programming algorithm for a stochastic

multiproduct batch dispatch problem. Naval Research Logistics 50 742–769.

Pochet, Y., L. A. Wolsey. 1994. Polyhedra for lot–sizing with Wagner–Whitin costs. Mathematical

Programming 67 297–323.

Pochet, Y., L. A. Wolsey. 2006. Production Planning by Mixed Integer Programming. Springer,

New York.

Ruszczynski, A., A. Shapiro, eds. 2003. Stochastic Programming. Handbooks in Operations Research

and Management Science, vol. 10. Elsevier Science B. V.

Sen, S., H. D. Sherali. 2006. Decomposition with branch-and-cut approaches for two-stage stochastic

mixed-integer programming. Mathematical Programming 106 203 – 223.

36

Stadtler, H. 2003. Multi-level lot-sizing with setup times and multiple constrained resources: In-

ternally rolling schedules with lot-sizing windows. Operations Research 51 487–502.

Summa, M. Di, L. A. Wolsey. 2006. Lot-sizing on a tree. Tech. rep., CORE, UCL, Louvain-la-Neuve,

Belgium.

Tempelmeier, H., M. Derstroff. 1996. A Lagrangean–based heuristic for dynamic multilevel multi-

item constrained lotsizing with setup times. Management Science 42 738–757.

Topaloglu, H., W. B. Powell. 2006. Dynamic programming approximations for stochastic, time-

staged integer multicommodity flow problems. INFORMS Journal on Computing 18 31–42.

van Hoesel, C. P. M., A. Wagelmans. 1996. An O(T 3) algorithm for the economic lot-sizing problem

with constant capacities. Management Science 42 142–150.

Wagelmans, A., A. van Hoesel, A. Kolen. 1992. Economic lot sizing: An O(n log n) algorithm that

runs in linear time in the Wagner–Whitin case. Operations Research 40 145–156.

Wagner, H. M., T. M. Whitin. 1958. Dynamic version of the economic lot size model. Management

Science 5 89–96.

Wolsey, L. A. 1998. Integer Programming . Wiley, New York.

Zipkin, P. H. 2000. Foundations of Inventory Management . McGraw-Hill.

37