One-dimensional cutting problems: models and algorithms

models and algorithms for
one-dimensional cutting problems
Fabrizio Marinelli
fabrizio.marinelli@univpm.it
Università Tor Vergata
Roma, November 2013
Università Politecnica delle Marche

Fabrizio Marinelli - Cutting problems 2
Road map
 A typology of cutting problems
 The one-dimensional cutting stock problem
 Complexity: NP-completeness and polynomial cases
 Four integer program formulations
 Solution methods: heuristics, approx results, exact algorithms
and topics packing

The problem

Cutting problem
“large objects” (stock) have to be cut up into
“small objects” (parts or part-types) in order to
fulfill a given requirement of parts.
Five sub-problems can be distinguished:
1. how select the stocks,
2. how select the parts,
3. how group the parts,
4. how allocate the groups of parts to stocks,
5. how lay out the parts on stocks.

An example
supply of Stocks (warehouse) demand of Parts (Production bill)
 4
 15
 6
cutting pattern: a (geometric)
assignment of parts to stocks.
activation level
INPUT: geometric objects of given shape
OUTPUT: (unordered) set of cutting operations

 [definition] A cutting pattern is a vector p  Nn that describes how
to cut a single stock: the i-th component indicates how many parts
of type i are produced by adopting the pattern.
 [definition] The activation level of a cutting pattern p is the
number of stocks processed according to p.
In math terms…

Cutting in industry
Textile - Missoni (Italy),…
Paper - Pine Falls (Canada) Stone Consolidated (Canada, UK), ...
Industrial woodworking – IKEA (Sweden),…
Steel bars – Hydro (Italy, Norway),…
Glass – Pilkington (Italy, France), ...
Rubber – Dayco (Italy, Belgium), ...
Logistics – Pallet Loading, assortment, pallet layout,…

Other applications: Multiprocessor scheduling
[problem] Multiprocessor Scheduling
 n jobs, all released at time zero, each requiring a given processing time pi
 m machines, each available for a time interval [0, D]
 no due dates or precedence constraints; preemption is not allowed.
Is there a schedule which ﬁts all n jobs onto the m machines?
We are asking whether n bars, with lengths pi ,
can be bin-packed into m bins of length D.

Other applications: Assembly Line Balancing
Task to workstation assignment (cutting plan)
t1 t2 t6 t5 t8 t3 t10 t4 t7 t9 t11
Workstations (bins)
Cycle time
t2 t6 t8
Tasks (production bill)
t1
t5
t3
t10
t4
t7
t9
t11
Generalized Bin Packing Problem

Geometrical characteristics
 Dimensionality
 Part Shape
Regular
Convex
Irregular
two-dimensional
(sheet, panels, clothes)
 Cut Shape
one-dimensional
(rods, bars) Rotation allowed
Guillotine
Nested

Combinatorial characteristics
 Stocks and Parts Assortment
 one Stock, many identical Stocks, distinct Stocks;
 one type and many parts, few types and many parts per type,
many types and one or few parts per type.
 Parts to Stocks Assignment
 All stocks are required to obtain a selection of parts;
 All parts must be produced by using a selection of stocks.

 Dyckhoff, H, A typology of cutting and packing problems, 1990
 4-fields notation  /  /  / 
Typology of cutting & packing problems
1. Dimensionality
(1) one-dimensional
(2) two-dimensional
(3) three-dimensional
(N) N-dimensional
2. Kind of assignment
(B) all stocks and a selection of parts
(V) a selection of stocks and all parts
3. Assortment of stocks
(O) single stock
(I) identical figure
(D) different figures
4. Assortment of parts
(F) few parts (of different types)
(M) many parts of many different types
(R) many parts of relatively few different parts
 Some ambiguity problems, i.e., the well-known Vehicle Loading Problem is
coded both as 1/V/I/F and 1/V/I/M

Typology of cutting & packing problems
 Wäsher et al.,
An Improved typology of cutting and packing problems, 2007
Criteria:
 dimensionality:
1D, 2D, 3D;
 kind of assignment:
output maximization, input minimization;
 assortment of parts:
identical, weakly heterogeneous, strongly
heterogeneous;
 assortment of stock: one, several;
 shape of parts: regular, irregular.
Basicproblems
Intermediateproblems
Refinedproblems

Typology: basic problems
C&P problems
Output
maximization
Input
minimization
kind of
assignment
identical
weakly
heterog.
strongly
heterog.
all dimension fixed
Assortment
of parts
identical
item
packing
placement Knapsack
Open
dimension
Cutting
Stock
(CSP)
Bin
Packing
(BPP)
basic
problem
Arbitrary
weakly
heterog.
strongly
heterog.
variable
dimension (s)
all dimension fixed

Typology: intermediate problems
Input minimization
parts
weakly heterogeneous strongly heterogeneous
stocks
identical
weakly
heterogeneous
strongly
heterogeneous
alldimensionfixed
One large stock
Variable
dimension(s)
Single Stock Size CSP
SSSCSP
Multiple Stock Size CSP
MSSCSP
Residual CSP
RCSP
Single Bin Size BPP
SSSBPP
Multiple Bin Size BPP
MBSBPP
Residual BPP
RBPP
Open Dimension Problem
ODP

Community
 ESICUP (EURO Special Interest Group on Cutting and Packing)
 Founded in 1988 and EURO Working Group since 2003
 Around 500 members worldwide
 Around 600 papers between 1995 and 2004
1D 2D 2D 3D tot
regular irregular
Input minimization 108 79 52 24 263
Output maximization 64 71 12 35 182
tot 172 150 64 59 445

The one-dimensional case

Cutting Stock Problem (CSP)
 a sufficient number m of stocks of length L
 a production bill Q consisting in n part-types. Part-type i is described by the
length li and the number di of items to be produced.
INPUT
OUTPUT
 A set {p1,…, pK} of cutting patterns and relevant activation levels.
 The problem is feasible if: li < L for all i

An example
L = 10 m
Stocks Production bill Q
l1 = 7
l3 = 4
l2 = 3
d1 = 5
d2 = 10
d3 = 5
(0,2,1)
(1,0,0)
 5
 5
= (0,10,5)
= (5,0,0)
[Solution 1] Cutting
patterns
Activation
level
Production
(5,10,5)10Trim loss = 3  5 = 15m

An example
L = 10 m
l1 = 7
l3 = 4
l2 = 3
d1 = 5
d2 = 10
d3 = 5
(0,2,1)
(0,3,0)
 1
 1
= (0,2,1)
= (0,3,0)
[Solution 2] Cutting
patterns
Activation
level
Production
(5,10,5)9
(1,1,0)
(0,0,2)
 5
 2
= (5,5,0)
= (0,0,4)
Trim loss = 2  2 + 1  1 = 5m

Some equivalent variants
TxLdltrimloss
i
i
n
i
ii minminmin
11
  
 If stocks are identical, number of stocks minimization and trim loss
minimization are equivalent problems.
Let T = xi be the number of used stocks in an optimal solution:
 Satisfy exactly or at least the demand of parts are equivalent problems
Clearly, the latter is a relaxation of the former and optimal solutions with
the same value can always be obtained from an optimal solution of the
latter by removing the surplus of parts.

Cutting Stock & Bin Packing
 In principle, Bin Packing Problem (BPP) and CSP are equivalent.
 The size of the input of a BPP instance is exponential in the size of
the corresponding instance of CSP
 polynomial-time algorithm for BPP is not necessarily polynomial-
time for CSP
 polynomial-size formulation for BPP is not necessarily polynomial-
size for CSP

Problem complexity: preliminaries
 [definition] A Polynomial Time Approximation Scheme (PTAS) is an algorithm
which computes, for any given ε > 0, a solution zA within a factor 1 + ε of being
optimal, i.e., zA < (1 + ε) z*. The running time of a PTAS is required to be polynomial
in the size of the problem for every fixed ε.
 [definition] A Fully Polynomial Time Approximation Scheme (FPTAS) is a PTAS
algorithm having a running time polynomial in the size of the problem and in 1/ε for
any ε > 0.
 [definition] An Asymptotic Polynomial Time Approximation Scheme (APTAS) is a
PTAS algorithm only when z* > C(ε) for a given function C of ε.

Problem complexity
CSP is strongly NP-hard and is NP-hard to approximate within a
factor less than 3/2 (i.e., there is no PTAS algorithms for CSP unless
P = NP)
The decision version of CSP is in NP (EisenbrandShmonin, 2006)
CSP with n = 2 part-types is polynomial:
the algorithm by McCormick et al. (2001) runs in O(log2 L)
the algorithm by Agnetis  Filippi (2005) runs in O(log L)
CSP with a fixed number n > 3 of part-types is polynomial (Goemans
– Rothvoss, 2013)

Problem complexity: NP-hardness
P = NP)
 [Theorem] deciding if BPP has a solution with 2 bins is NP-complete
[proof] Let {l1,…,ln} be an instance of PARTITION. Consider an instance of BPP
with items {l1,…,ln} and 2 bins li / 2 long.
l1 ln
l2
li / 2 li / 2
The BBP instance is a yes-instance iff the PARTITION instance is a yes-instance.

P = NP)
 [Corollary] BPP is NP-hard to approximate with ratio < 3/2
[proof] an approximation algorithm with ratio  < 3/2 should solve a yes-instance of
PARTITION in polynomial time (since  2 < 3 = 2 bins)

P = NP)
 [Theorem] deciding if BPP has a solution with m bins is strongly NP-complete
[proof] Reduction from 3-DIMENSIONAL MATCHING
Given
 3 finite disjoint sets X = {1,…,}, Y = {1,…,}, Z = {1,…,},
 and a set T  X × Y × Z of m triples,
the set M  T is a 3-dimensional matching if
 |M| = 
 xi ≠ xj, yi ≠ yj, and zi ≠ zj for any two distinct triples i = (xi, yi, zi)  M and
j = (xj, yj, zj)  M.

Problem complexity: NP-hardness (cont’d)
P = NP)
 [Theorem] deciding if BPP has a solution with m bins is strongly NP-complete
[proof] Reduction from 3-DIMENSIONAL MATCHING
4
3
2
1
4
3
2
1
4
3
2
1
ZYX
 T = {(1,1,2), (2,2,1), (3,4,3), (3,3,3), (4,4,4)}
 M = {(1,1,2), (2,2,1), (3,3,3), (4,4,4)}

Problem complexity: NP-hardness (cont’d)
 Let (x1, y1, z1)…(xh, yh, zh)…(xm, ym, zm) be an arbitrary sequence of the triples in T
 Define an instance I of BPP with
 m bins
 L = 404 + 15 ( is a large number, i.e., 100)
 n = 4m items (4 items for each triple h = (xh, yh, zh) in T )Z
h
Y
h
X
hh llll ,,,






111
110
4
4


h
hX
h
x
x
l
for the first occurrence of xh in the sequence
for the subsequent occurrence of xh






211
210
24
24


h
hY
h
y
y
l
for the first occurrence of yh in the sequence
for the subsequent occurrence of yh






48
410
34
34


h
hZ
h
z
z
l
for the first occurrence of zh in the sequence
for the subsequent occurrence of zh
324
810  hhhh zyxl 

From a 3D-matching to a bin packing
A sequence of triples such that the triples of M contain only first occurrences and
the triples of T M contain only subsequent occurrences
 T = {(1,1,2), (1,2,1), (2,2,1), (1,2,3), (3,4,3), (3,3,3), (4,4,4)}
 M = {(1,1,2), (2,2,1), (3,3,3), (4,4,4)}
(1,1,2), (2,2,1), (3,3,3), (4,4,4), (1,2,1), (1,2,3), (3,4,3)
An arbitrary sequence of triples
(1,1,2), (1,2,1), (2,2,1), (1,2,3), (3,4,3), (3,3,3), (4,4,4)
T MM
A packing into m bins is obtained by filling each bin with the items associated to
each triple. Indeed…

Length of triples
The length of a triple of all first
occurrences equals the length of the bin
324
810  hhhh zyxl 
+
110 4
  h
X
h xl
210 24
  h
Y
h yl
410 34
  h
Z
h zl
+
+
=
1540 4
 L
The length of a triple of all subsequent
occurrences equals the length of the bin
111 4
  h
X
h xl
211 24
  h
Y
h yl
48 34
  h
Z
h zl
324
810  hhhh zyxl 
+
+
+
=
1540 4
 L

From a bin packing to a 3D-matching
mLm  )1540( 4

 Let u(k) be the number of occurrences of k in the triples of T.
The total length of items is SUM( I ) =
=

Zk
kuk )(3
mm 48)1(10 44
 
)810( 4
m + 

ZkYjXi
kukjujiui )()()( 32

+mm  44
11)1(10  

Xi
iui )(
+mm 211)1(10 44
  

Yj
juj )(2

Property 1: any solution exactly fills the m bins

Properties of the item lengths
 The largest items is 410 34
 
)(810 324
  The smallest items is
L
4
1
4
15
10 4
 
Property 2: in any solution,
each bin contains exactly 4
items
L
3
1
5
3
40 4
 

Properties of the item lengths (cont’d)
 From Property 1 (any solution exactly fills the m bins) and L = 404 + 15
S = L and S mod  =15
 Let S be the sum of the item sizes in a bin.
 15 must be obtained with the residuals 1, 2, 4, 8 of the item sizes.
 There is only one way to obtain 15 by summing four numbers (Property 2:
(each bin contains exactly 4 items), with repetition allowed, out of 1, 2, 4, 8.
Each bin must contain (exactly) an item lh associated to a triple h = (xh, yh, zh),
an item li
X , an item lj
Y and an item lk
Z

14
  i
X
i
X
i xCl +
810 324
  hhhh zyxl +
224
  j
Y
j
Y
j yCl +
 S mod 2 = 15
434
  k
Z
k
Z
k zCl =
15)()()( 324
  hkhjhiS zzyyxxCS
(xi – xh) + 15 = 15 xi = xh
 S mod 3 = 15
 S mod 4 = 15
(yj – yh)2 + 15 = 15
(zk – zh)3 + 15 = 15
yj = yh
zk = zh
The bin must contain (exactly) an item lh associated to a triple h = (xh, yh, zh),
and the items lh
X , lh
Y , lh
Z associated to the components of h

14
  i
X
i
X
i xCl
224
  j
Y
j
Y
j yCl
434
  k
Z
k
Z
k zCl
810 324
  hhhh zyxl
+
+
+
=
15)()()( 324
  hkhjhiS zzyyxxCS
40:10  Z
k
Y
j
X
iS CCCC
10 + 10 + 10 + 10 a triple of all first occurrences
10 + 11 + 11 + 8
a triple of all subsequent
occurrences
The bins containing triples of all first occurrences describe a 3D matching

A 3D matching
From a bin packing to a 3D-matching
 T = {(1,1,2), (1,2,1), (2,2,1), (1,2,3), (3,4,3), (3,3,3), (4,4,4)}
 M = {(1,1,2), (2,2,1), (3,3,3), (4,4,4)}
An arbitrary
sequence of triples
1 1 2 1 3 3 4
1 2 2 2 4 3 4
2 1 1 3 3 3 4
A bin packing
l1 l2 l3 l4 l5 l6 l7
l1
X l1
X l2
X l1
X l3
X l3
X l4
X
l1
Y l2
Y l2
Y l2
Y l4
Y l3
Y l4
Y
l2
Z l1
Z l1
Z l3
Z l3
Z l3
Z l4
Z

Problem complexity: CSP2
CSP with n = 2 part-types is polynomial:
the algorithm by McCormick et al. (2001) runs in O(log2 L)
 Given a CSP2 instance (decision version): l1, l2, d1, d2, m, L w.l.o.g.  N {0}
 Let P be the convex hull of all the feasible cutting patterns:
P = {p  N2 | l1 p1 + l2p2 < L}
 [definition] A triangle is unimodular if has integral vertices and area equal to 1/2.

Problem complexity: CSP2
 [theorem] If the point M = (d1/m, d2/m) is in a unimodular triangle contained in P
then the CSP2 instance is feasible. If M is not in P the instance is infeasible.
 Consider a unimodular triangle T = (p1, p2, p3) and the matrix











111
321
321
yyy
xxx
ppp
ppp
B
 If M  T then M is a convex combination of (p1, p2, p3), i.e., the system
B = [M, 1]T admits a non negative solution  .
 Let x = m 
 Since the area of T is ½ |det(B)|, then
T unimodular implies B unimodular.
 [d1,d2, m] is integer.






























m
d
d
x
x
x
ppp
ppp
yyy
xxx
2
1
3
2
1
321
321
111
x is integer

Algorithm by McCormick et al.: step 1
 Step 1: compute the O(log L)
vertices of P by Harvey’s
Algorithm in O(logL) and draw
conv(P) in O(logL loglogL)
P = {p  N2 | 3 p1 + 4 p2 < 25}

P = {p  N2 | 3 p1 + 4 p2 < 25}
 Step 2: if M is in P we have
done.
 [example] for [d1,d2, m] = [10,
7, 3] we have M = [10/3, 7/3]
and M = [4, 3]
M
M
p1 p2
p3

P = {p  N2 | 3 p1 + 4 p2 < 25}
 Step 3: compute the axial
triangles in O(log L). An axial
triangle is prime if its sides are
coprime integers
 The point M is in one of such
triangles.

 Step 4: if M is in a not prime axial triangle T
with sides a and b, then decompose T in prime
axial triangles with sides
a′ = a / gdc(a,b) and
b′ = b / gdc(a,b) .
a = 4, b = 2
gdc(a,b) = 2
a′ = 2, b′ = 1
a
b
T  The point M is in one of such triangles.
If a′ = b′ = 1 we have done.

 Step 5:
Bézout’s identity: gdc(a,b) = pa  qb with p, q  N
Consider the kS southeast step triangles:
from (0, b) in the direction (q,− p)
 a = 3, b = 8
 1 = 3a – 1b p = 3, q = 1
(a, 0)
(0, b)
 p
q
(1, 5)
(2, 2)

 Step 5:
Bézout’s identity: gdc(a,b) = pa  qb with p, q  N
Consider the kN northwest step triangles:
from (a, 0) in the direction (q − a, b − p)
 a = 7, b = 19
 1 = 11a – 4b p = 11, q = 4
(a, 0)
(0, b)
b  p
q  a
(4, 8)
(1, 16)

 [Proposition] Any steps triangle is unimodular.
 [Proposition] min{kS , kN } = 1 and max{kS , kN } > 2
 Step 5: w.l.o.g. suppose kS > 2
 Case A: point M is in one of the steps triangles
(the check is made indirectly, without drawing the triangles)
(a, 0)
(0, b)
M

 [Proposition] Any steps triangle is unimodular.
 [Proposition] min{kS , kN } = 1 and max{kS , kN } > 2
(a, 0)
(0, b)
 Step 5: w.l.o.g. suppose kS > 2
 Case B: point M is in one of the new
axial triangles. Goto step 3
M

Algorithm by McCormick et al.
draw conv(P)O(logL loglogL)Step 1
yes
compute the axial triangles and
find that containing M
Step 3 O(logL)
compute gdc(a,b) and decompose
the triangle in prime axial triangles
Step 4 O(logL)
Step 5 M is in one of the steps trianglesO(logL)
check trivial casesStep 2 O(logL)
no
O(logL)

Problem complexity
The decision version of CSP is in NP (EisenbrandShmonin, 2006)
 Not trivial since the number of cuts grows with the demand and therefore the size
of the optimal value could be exponential in the problem size.
The result is a direct consequence of the integer analogues of
 [Carathéodory’s theorem] Let X  Rn be a finite set. If b  cone(X), there is a
subset Y of X consisting of n points such that b  cone(Y)
 [Theorem] Eisenbrand – Shmonin, 2006
 Let X  Zn be a finite set of nonnegative integer points. If b  int.cone(X),
there exists a subset Y of X with |Y| < size(b) such that b  int.cone(Y).
 Let P  Rn be a convex set. If b  int.cone(X), there exists a subset Y of X
with |Y| < 2n such that b  int.cone(Y).

Problem complexity: CSP with n > 3
CSP with a fixed number n > 3 of part-types is polynomial (2013)
 decision version of CSP: can the demand d be expressed as an integer conic
combination ixi of the points in the set X = {x  Nn | lTx < L}?
P = {x  R2 | 3 x1 + 4 x2 < 20}
l = (3, 4), d = (7, 9), and L = 20
d
x1
x2
x3
1 = 2
2 = 1
3 = 1
Problems
 Points in X are exponentially many in size(L)
 Sizes of  can be exponential in size(d)

Polynomiality for fixed number of part-types
1. Problem: points in X are exponentially many in size(L)
Solution: for fixed n, Eisenbrand and Shmonin showed that the integer
cone of X can be generated by a constant number of integer points in P
2. Problem: size() can be exponential in size(d)
Solution: uhm…
The problem cannot be directly formulated as an ILP with a constant
number of variables and then solved in polynomial time (Lenstra, 1983)
… unless you provide a bound of size() which only depends on n

Polynomiality for fixed number of part-types
 [Theorem] Goemans – Rothvoss, 2013
Let P, Q  Rn be two polytopes and X = P  Nn .
 Any y  int.cone(X)  Q can be expressed as an integer conic combination of
at most 22n + 1 points of X
 The coefficients can be computed in time)1(2
)()(
)(
O
QsizePsize
nO

 [Corollary] CSP can be solved in polynomial time for any fixed number n of
part-types
By choosing P = {(x1, …, xn, 1) | lTx < L}
and Q = {d}  [0, z] we can decide in
polynomial time whether z cuts suffice.
Then use binary search on [0, z]
P
(d,0)
Q
(d,z)

Thm by Goemans and Rothvoss (proof sketch)
Facts
 X can be covered by at most N < mnnO(n)logn many integral parallelepipeds 
in NO(1) time

Facts
in NO(1) time
3x
x
v1
v2
y1
= 1v1 + 6v2 + y1
2. Any integer point d = x, with   N and x integer point of , can be rewrite
in terms of an integer conic combination of the vertices of  plus the sum of at
most 2n integer points of 

Facts
in NO(1) time
2. Any integer point d = x, with   N and x integer point of , can be rewrite
in terms of an integer conic combination of the vertices of  plus the sum of at
most 2n integer points of 
3. Any point d  int.cone(X) can be expressed as iyi with i  N and
yi  Y  X, | Y | < 2n (Eisenbrand – Shmonin, 2006)
For any yi with i > 0, take the parallelepiped  containing yi and rewrite iyi
by using 2.
d can be rewritten as an integer conic combination of at most 22n points of
X (vertices of parallelepipeds) plus at most 22n point of X (extra points)

P = {x  Rn | Ax < b} Q = {x  Rn | Dx < f} A(m  n), D(m´  n)
Choose Y  Ext() = vertices of parallelepipeds of P, |Y| < 22n, times
 Coefficients of the integer conic combination and extra points are unknown but we
can compute them by an ILP with a constant number of variables
Extra points must be in P
d = sum of extra pts + y  int.cone(Ext())
d must be in Q
nn
i
i
i
Y
n
i
i
Y
ib
n
2
2
1
2
21
21
2





 
N
N
x
v
fDd
dxv
Ax
v
v
v










n
n
N
2
2
2

 Coefficients of the integer conic combination and extra points are unknown but we
can compute them by an ILP with a constant number of variables
nn
i
i
i
Y
n
i
i
Y
ib
n
2
2
1
2
21
21
2





 
N
N
x
v
fDd
dxv
Ax
v
v
v


Variables Constraints
m22n
n
P = {x  Rn | Ax < b} Q = {x  Rn | Dx < f} A(m  n), D(m´  n)
Choose Y  Ext() = vertices of parallelepipeds of P, |Y| < 22n, times
m´
22n 22n
n22n n22n
constant polynomial








n
n
N
2
2
2

Asymptotically exact algorithms
 Karmarkar – Karp, 1982
zH < z* + O(log 2 n) AFPTAS
 Jansen – Solis-Oba, 2011
zH < z* + 1 in O((log2 ∑di + log L)3 log5 ∑di)
 Agnetis – Filippi, 2005
zH < z* + n – 2 in O(poly(log L))

Models

Literature
 1960 - L. Kantorovich “Mathematical methods of organising and planning
production”, Management Science
 1961 – 1963 - Gilmore, Gomory “A Linear Programming Approach to the
Cutting Stock Problem”, Operations Research
 1981 - H. Dyckhoﬀ, “A new linear programming approach to the cutting stock
problem”, Operations Research
 1999 - J.M. Valério de Carvalho, “Exact solution of bin-packing problems using
column generation and branch-and-bound”, Annals of Operation Research
 2003 - G. Belov, R. Weismantel. “A class of subpattern formulations for 1D stock
cutting”, tech. rep.

Notation
m = number of available stocks
L = stock length
Q = production bill
n = number of parts (n = |Q|)
di = demand of parts of type i (1  i  n)
li = length of part-type i (1  i  n)
z* = optimal value: minimum number of required stocks
P = set of all feasible cutting patterns (N = |P|)

Assignment model (Kantorovich, 1939)
xij  N number of parts of type i cut from the stock item j
 Decision variables
yj  {0,1} 1 if the stock item j is used, 0 otherwise
part-type requirements
cut feasibility
 [KAN] formulation:
mjLyxl
nidx
yz
j
n
i
iji
i
m
j
ij
m
j
j









1
1
min
1
1
1
* minimize the number of used
stocks


n
i
idm
1














n
i i
i
l
L
dm
1
/or

How many stocks?
m must be not less than the minimum number of required stocks.


n
i
idm
1














n
i i
i
l
L
dm
1
/
max number of stocks required to cover the demand of part type i.
 more precisely:
Parts of type i achievable from a single stock
 trivially, one stock per part:

An example
m = 1 + 3 + 1 = 5
L = 10
Stocks
Production Bill Q
l1 = 7
l3 = 4
l2 = 3
d1 = 1
d2 = 8
d3 = 2
z* = min y1 + y2 + y3 + y4 + y5
Requirements
x11+ x12+ x13 + x14 + x15  1
x21+ x22+ x23 + x24+ x25  3
x31+ x32+ x33 + x34+ x35  1
Cut feasibility
7 x11 + 3 x21 + 4 x31  10 y1
7 x12 + 3 x22 + 4 x32  10 y2
7 x13 + 3 x23 + 4 x33  10 y3
7 x14 + 3 x24 + 4 x34  10 y4
7 x15 + 3 x25 + 4 x35  10 y5
Variable domains
xij  N i = 1,…,3 j = 1,…,5
y1 y2 y3 y4 y5  {0,1}

Pattern-based model (Gilmore-Gomory, 1961)
Given the set P = {p1,…, pN} of all feasible cutting patterns, define the integer
variables
xj  N indicating the activation level of cutting pattern pj
 [GG] formulation:
nidxp i
N
j
jij 
1
1


N
j
jxz
1
*
min
minimize the number of used
stocks
)( L
nON 
Compact form: z* = min{1Tx: Ax > d, x > 0, integer} A(n  N), x  NN

An example
L = 10
Stocks
Production bill Q
l1 = 7
l3 = 4
l2 = 3
d1 = 1
d2 = 8
d3 = 2
4 maximal cutting patterns:











0
1
1
1p











0
3
0
2p











1
2
0
3p











2
0
0
4p
z* = min x1 + x2 + x3 + x4
requirements
p1 x1 + p2 x2 + p3 x3 + p4 x4  d
Variable domains
x1 x2 x3 x4  N

An example
L = 10
Stocks
l1 = 7
l3 = 4
l2 = 3
d1 = 1
d2 = 8
d3 = 2











0
1
1
1p











0
3
0
2p











1
2
0
3p











2
0
0
4p
z* = min x1 + x2 + x3 + x4
requirements
x1  1
x1+ 3x2+ 2x3  8
x3 + 2x4  2
Variable domains
x1 x2 x3 x4  N
 [note] in case of requirement constraints in terms of equality, also non-maximal
cutting patterns are required to guarantee feasibility.
4 maximal cutting patterns:
Production bill Q

0 2 31 4 5
Arc-flow model (de Carvalho, 1999)
 Oriented acyclic graph G(V, A)
 V = {0,1,2,…, L};
 an edge between i < j if there is a part-type j i long;
 Additional edges (k, k + 1), 0 < k < L  1, and (L , 0).
[example]
L = 5,
n = 2,
l1 = 2, l2 = 3
 Any path from 0 to L describes a valid cutting pattern
 A circulation of one unit flow describes a single cut.

Arc-flow model (de Carvalho, 1999)
xij  N flow through the edge ( i , j )
 [deC] formulation:
nkdx
Ljf
Lj
jf
xx
fz
k
Alii
lii
Akj
jk
Aji
ij
k
k
















1
1,...,10
0
min
),(
,
),(),(
*
minimize the number of
used stocks
flow conservation, i.e.,
valid cutting patterns

An example
z* = min f
flow conservation
node 0: f  x02  x03  x04 = 0
node 2: x02  x24  x25  x23 = 0
node 3: x35 + x34  x03  x23 = 0
node 4: x45  x24  x04  x34 = 0
node 5: f + x35 + x25 + x45 = 0
0 2 31 4 5
[Instance] L = 5, n = 3, l = (4,3,2) d = (1,8,2)
Requirements
x04 > 1
x03 + x25 > 8
x02 + x24 + x35 > 2

Sub-pattern model (BelovWeismantel, 2003)
 Idea: patterns are not explicitly described. They are obtained by
combining subpatterns












































0
0
2
...
0
0
4
0
0
2
0
0
1 1
11121110
K
Kpppp
phk = 2keh h = 1,…,n and k = 0,…,Kh
   hh lLd /,minlog


h k
hkjhkj pp 
4
0
0
0
2
0
0
0
0
0
2
0
0
0
0
2
0
0
0
1

































































j10 = j11= j21 = j41= j42 = 1
6
0
2
3












jp
xj  N activation level of pattern pj j = 1 ,…, N´
jhk  {0,1} 1 if subpattern phk is used to form pattern pj, 0 otherwise
yjhk  N activation level of subpattern phk as part of pattern pj

 [BW] formulation:
nhdy h
N
j
K
k
jhk
k
h


 
12
1 0




N
j
jxz
1
*
min
minimize the number of used stocks
size(d) + size(z*)
NjLl
n
h
K
k
jhkh
k
h

 
12
1 0

jhkj yx 
jhkk
h
jhk
d
y 




2
cutting pattern feasibility
act. level of pj cannot be smaller than the
act. levels of forming subpatterns
act. levels of phk in pattern j can be
positive only if phk forms pj

What’s the best model?

some preliminaries :
Implicit Enumeration

Implicit enumeration
[principle] Divide et Impera
 The problem P is recursively decomposed (branch) in subproblems
P1, …, Pk, smaller and easier to solve.
 Not interesting subproblems, i.e., subproblems whose solutions are surely
suboptimal for P, are removed (bounding) from the enumeration tree
x1
x2
P
x1
x2
P1
P2
 Subproblems are arranged
in an enumeration tree
P
P1 P2

Branch-and-bound algorithm
0. Initialization: l = P; x = ; zU = 
1. Stop criteria: if l =  then x is an optimal solution. STOP.
2. Subproblem selection: choose a subproblem Pi from l and remove it from l
3. Subproblem evaluation: if Pi is infeasible go to 1.
Let xi
R be an optimal solution of Pi
R (relaxation of Pi)
4. Bounding: if c(xi
R) > zU then go to 1.
if xi
R is integer then zU = c(xi
R); x = xi
R; go to 1.
5. Branching: decompose Pi into subproblems Pi1,…,Pik such that
Pi = jPij and add the subproblems to l; go to 1.

branch-and-bound: optimality gap
1
2
3
4
5 6
 At a generic iteration, the list l contains the subproblem still to be solved (active
subproblems); they are the leaves of the current enumeration tree.
active
subproblems
zL = minil{c(xi
R)}c(x1
R)
c(x2
R) = c(x6
R)
c(x4
R)
c(x3
R)
c(x5
R)
zU
optimality gap = zU  zL
gap% =
zU  zL
zL

branch-and-bound: convergence
 The gap decreases from above when the value zU is updated (by pruning for
optimality or by heuristics).
 The gap eventually increases from below when a subproblem defining zL (best
bound) is selected from l.
zL = c(x0
R)
zU
z
t
initial gap gap at time t

branch-and-bound efficiency
The efficiency of the algorithm strongly depends on several factors:
Search strategy
 subproblem selection (step 2.),
 Type of branching
 branching variable (step 5.)
Formulation quality (size, tightness, symmetries,…)
Relaxations adopted to compute bounds
Heuristics adopted to compute incumbents
…

[KAN] model: discussion
 Easy to handle.
 The number of variables and constraints is exponential in the size
of the input (the numbers m + n of constraints and m(n + 1) of
variables grow with the total demand).
 An optimal solution might be of exponential size.
 The lower bound given by the continuous relaxation is very weak.
 The model exhibits symmetries: solutions obtained by stock index
permutations are equivalent; bounding is ineffective.

[KAN] model: continuous relaxation








L
dl
z
ii
R
*
 [Theorem] Martello – Toth (1990), originally derived for BPP The lower
bound z*
R given by the continuous relaxation of [KAN] is:
 [proof for the BPP]
The value of the solution xii = 1, xij = 0 (i  j), yi = li/L is
li / L
and clearly no solution can be lower than that. Round up, because the number
of stocks must be integer.
 For instances with large loss the bound can be very poor, i.e.
2
*
* z
zR 

continuous relaxation
of [KAN] model
zR
* = min y1 + y2
x11+ x12  2
5.01 x11  10 y1
5.01 x12  10 y2
x11 , x12 > 0
0 < y1 , y2 < 1
 [Instance] L = 10, n = 1, l1 = 5.01, d1 = 2.
2 stocks are required, therefore z* = 2.
[KAN] model: continuous relaxation
The optimality gap is nearly 50%
Solution x11= x12 = 1 and y1= y2 = 0.501 is feasible
and values 1.02, hence is optimal.
Clearly 02.111*

L
dl
zR

[KAN] model: discussion
 Easy to handle.
 The number of variables and constraints is exponential in the size
of the input (the numbers m + n of constraints and m(n + 1) of
variables grow with the total demand).
 An optimal solution might be of exponential size.
 The lower bound given by the continuous relaxation is very weak.
 The model exhibits symmetries: solutions obtained by stock index
permutations are equivalent; bounding is ineffective.

L = 10
Stocks
Production bill Q
l1 = 7
l3 = 4
l2 = 3
d1 = 5
d2 = 14
d3 = 3
The optimal value is 10. Demands can be
satisfied activating cutting patterns p1 and
p2 both at level five.











1
2
0
1p











0
1
1
2p
[KAN] model: symmetries

y1 = … = y10 = 1, yi = 0 i > 10
x11 = 0, x21 = 2, x31 = 1
x12 = 0, x22 = 2, x32 = 1
…
x15 = 0, x25 = 2, x35 = 1
x16 = 1, x26 = 1, x36 = 0
x17 = 1, x27 = 1, x37 = 0
…
x1,10 = 1, x2,10 = 1, x3,10 = 0
An optimal solution
y1 = … = y10 = 1, yi = 0 i > 10
x11 = 1, x21 = 1, x31 = 0
x12 = 0, x22 = 2, x32 = 1
…
x15 = 0, x25 = 2, x35 = 1
x16 = 0, x26 = 2, x36 = 1
x17 = 1, x27 = 1, x37 = 0
…
x1,10 = 1, x2,10 = 1, x3,10 = 0
All the permutations of stock indices 1,…,10 are (equivalent) optimal solutions...
The same solution obtained by swapping
the indices of stocks 1 and 6

… optimal solutions “evenly” spread among the leaves of the tree (red leaves in
the figure):
 Since zi
L < zi
* < zU for each subproblem i,
a node can be fathomed if its sub-tree has
not any optimal solution (independently
from the adopted exploration strategy).
Symmetries makes ineffective the
bounding; in practice, the search tree is
almost completely visited.

[GG] model: discussion
 The number of variables is exponential in the size of the input. It is
O(nL/) where  is the length of the smallest part-type.
 There exists an optimal solution with a polynomial number of
activated patterns (Eisenbrand – Shmonin, 2006).
 The lower bound given by the continuous relaxation dominate the
combinatorial bound by MartelloToth (Vanderbeck, 1999) and is
very tight.
 The model does not exhibit symmetries.

The size of an optimal solution of [GG]
 [Carathéodory’s theorem] Let X  Rn be a finite set. If b  cone(X), there is a
subset Y of X consisting of n points such that b  cone(Y)
cone(X)
b
X
y1
y2

 [Theorem] EisenbrandShmonin (2005)
Let X  Zn be a finite set of nonnegative integer points. If b  int_cone(X), there
exists a subset Y of X with |Y| < size(b) such that b  int_cone(Y)
an upper bound for |Y| cannot be
given in terms of d
(1,4)
(1,2)
(1,1)
(3,7)

 W.l.o.g. let Y  X the smallest set s.t. 

Yx
xxb  x > 0, integer
 

Zx
xb  Z  Y
 Points are nonnegative, hence the number of distinct points
resulting by the sum of points in Z  Y is bounded by
 

n
i
ib
1
1
 If (by contradiction) than there exists a point p resulting by
the sum of two distinct subsets A, B of Y, i.e.
 

n
i i
Y
b1
12
 

BA xx
xxp
 Let A´ = A B and B´ = B A.
Clearly A´ and B´ are disjoint and not empty, and
 
 BA xx
xx
 

BABBAA xxxx
xxxx

 = min xA´{x}
 

AAYY x
x
x
x
x
x xxxb 

 

AAAY xx
x
x
x xxx  )(

 

BAAY xx
x
x
x xxx  )(

 

BABAY x
x
x
x
x
x xxx )()(
)(

 
 BA xx
xx
one of these coefficients is 0, i.e. there
exists Z  Y such that b  int_cone(Z)  
)(
1log2log 1
bsizeY
bY
n
i i

  
 

n
i i
Y
b1
12
contradiction

 [Corollary] Let z* = min{cTx: Ax = b, x > 0} A(m  n), aij  N, x  Nn, c  Nn.
If this integer program has a finite optimum with optimal value z*, then there
exists an optimal solution x* with at most size(b) + size(z*) nonzero components.
[Proof]





















































m
n
mn
n
n
mm b
b
z
x
a
a
c
x
a
a
c
x
a
a
c



1
*
1
2
2
12
2
1
1
11
1
The integer vector (z*, b)T is an integer conic combination of the column vectors
of the matrix (c, A)T; the solution x corresponds to the coefficients of the
combination.

[Corollary] The size of an optimal solution x* of the [GG] model is
polynomial in the size of the problem.
[Proof]
 z* < di since li < L, i
 size(z*) = log(z*+ 1) < log((di + 1)) < log(di + 1) = size(d)
 By the previous corollary supp(x*) < size(z*) + size(d)
 therefore supp(x*) < 2 size(d)
[GG] z* = min{1Tx: Ax = d, x > 0} A(n  N), x  NN

 The number O(nL) of variables is exponential in the size of the
input.
very tight.

 Given an integer 0 <  < L / 2 let
Martello & Toth combinatorial bound
I1 = {i : li > L –  }

I2 = {i : L / 2 < li < L –  }
I3 = {i :  < li < L / 2}
L / 2



















 





L
dl
d
dd
z
IIi
ii
Ii
i
Ii
i
Ii
i
LB
)( 32
1
21
max)(

each part in I1 and I2 requires a distinct bin; parts in I3 are neglected
continuous lower bound of parts in I2 and I3

I1 = {i : li > L –  }
L / 2

I2 = {i : L / 2 < li < L –  }
I3 = {i :  < li < L / 2}
 iLlzz iLBLB somefor2/:)(max  
 The maximum value of zLB() is achieved for  = li < L / 2


 [Theorem] Vanderbeck, 1999 For any feasible solution x of [GG] and 0 <  < L / 2
Martello & Toth bound vs [GG] bound
LB
Pi
i zx 







[Proof]
Let Pk = {p  P : pi > 0 for some i  Ik}. Notice that P1  P2 =  and P1  P3 = 
 

)( 2121 PPPi
i
Pi
i
Pi
i
Pi
i xxxx
  

11 Ii
i
Ii Pj
jij dxp   

22 Ii
i
Ii Pj
jij dxp because 1
21
 IIi
ijp
for all patterns pj
in P1 and P2

Martello & Toth bound vs [GG] bound






   2121 )(
,0max
Pi
i
PPi
i
PPPi
i xxx
L
dl
IIi
ii

)( 32
 )( 32 IIi
iidl
 2Ii
id
  

)( 32 IIi Pj
jiji xpl 

1PPj
jxL  









1 32 )(PPj
j
IIi
iji xpl

[GG] continuous relaxation
zR
* = min x1
x1  2
x1 > 0
[GG] model: optimality gap
The optimal solution of the continuous relaxation is x1 = 2 and integer.
The unique maximal cutting pattern is
 11 p
 [Instance] L = 10, n = 1, l1 = 5.01, d1 = 2.
2 stocks are required, therefore z* = 2.
The optimality gap is 0%

 In most cases the optimal solutions of the continuous relaxation of [GG] satisfy
the IRUP property (Integer Round Up Property):
z*   zR
*  = 0
 [Theorem] Marcotte, 1986
deciding if a given CSP instance has the IRUP property is NP-hard
 [Theorem] Filippi, 2007
z*   zR
*  < (n  1)/3 + 1

 [Theorem] Marcotte, 1985 IRUP holds for instances with n = 2 but not for n > 3
[Proof sketch]
CSP: min{1Tx: Ax > d, x > 0, integer} A(2  N), x  NN
 Columns of A are maximal cutting patterns, i.e., maximal integer points of the
polyhedron P = conv(X) where X = {xN2 | l1x1 + l2x2 < L}.
 P is integral;
 P is lower comprehensive (x  P and 0 < y < x  y  P);
 P satisfies the integral decomposition (kN > 2 and for any integral ykP = {kx
| x P}, the point y can be expressed as the sum of k integral points of P)
CSP has the IRUP property (Baum – Trotter, 1981).

 [Theorem] Marcotte, 1985
IRUP holds for instances with L < 8, and for instances having the
successive divisibility property
 [Definition] A CSP problem is said to have the property of successive
divisibility if there exists an order of part types such that:
l1 | l2 | … | ln, i.e., li divides li + 1 for i = 1,…, n
 [non IRUP instance]
l = (91, 26, 14), d = (1, 4, 12), and L = 182
z* = 3 and zR
* = 1.9945

[GG] model: MIRUP
 [Conjecture] Scheithauer – Terno, 1996
The optimal solutions of [GG] satisfy the Modified IRUP:
z*   zR
*  < 1
 [Theorem] The instances with n < 6 (Scheithauer – Terno,
1996) and n < 7 (Shmonin, 2008) satisfy the MIRUP
 Largest gap known is z*  zR
* = 7/6

 The number O(nL) of variables is exponential in the size of the
input.
very tight.

L = 10
Stocks
Production bill Q
l1 = 7
l3 = 4
l2 = 3
d1 = 5
d2 = 14
d3 = 3
The optimal value is 10. Demands can be
satisfied activating cutting patterns p1 and
p2 both at level five.











1
2
0
1p











0
1
1
2p
Such solution is described by [GG] model
in a unique way:
x1 = 5, x2 = 5, xi = 0 per i {1,2}
[GG] model: symmetries

[deC] model: discussion
 The size is exponential in the size of the input (the numbers L + n +
1 of constraints and O(nL) of variables grow with the stock length).
 The lower bounds given by the continuous relaxations of [deC] and
[GG] are the same.
 It is easy to rewrite a solution of [GG] (activation levels of cutting
patterns) into a solution of [deC] (circulation on G) and vice-versa.
 The model exhibits symmetries: several paths correspond to the same
cutting pattern.

From solutions of [deC] to solutions of [GG]
L = 10
Stocks
l1 = 5
l3 = 2
l2 = 3
d1 = 1
d2 = 8
d3 = 2
Production bill Q
0 2 31 4 5 6 8 97 10
 Flow decomposition property: any feasible flow can be decomposed into
 a sum of flows in paths from node 0 to node L plus
 a sum of flows around cycles

From solutions of [deC] to solutions of [GG]
L = 10
Stocks
l1 = 5
l3 = 2
l2 = 3
d1 = 1
d2 = 8
d3 = 2
Production bill Q
0 2 31 4 5 6 8 97 10
[GG] solution
x1 = 1 x2 = 1 x3 = 2 x4 = 0











0
1
1
1p











0
3
0
2p











1
2
0
3p











2
0
0
4p
1 1
1+2 1+1+2
1 + 2 1 + 2
1
2
 A solution with integer flow is
decomposed into an integer solution
of model [GG]

Models: pros & cons
mjLyxl
nidx
yz
j
n
i
iji
i
m
j
ij
m
j
jR









1
1
min
1
1
1
KAN
[KAN]
nkdx
Ljf
Lj
jf
xx
fz
k
Alii
lii
Akj
jk
Aji
ij
R
k
k
















1
1,...,10
0
min
),(
,
),(),(
deC
[deC]
nidxp i
N
j
jij 
1
1


N
j
jR xz
1
GG
min
[GG]
Size Tightness Symmetries

Model reformulation
Dantzig-Wolfe decomposition
1960 - G. Dantzig, P. Wolfe, “Decomposition Principle for Linear Programs”, Operations Research
1958 - L. Ford, D. Fulkerson, “A suggested computation for maximal multi-commodity network flows”,
Management Science

[Teorema] Resolution Theorem (Weyl-Minkowski, 1936)
Let P be a non-empty polyhedron with at least one extreme point.
Then
P = conv(ext(P)) + rec(P)
P
v1
v2
v3
conv(Ext(P))
rec(P)
x
d
u
Inner representation of polyhedra

The decomposition principle
fDx
bAx
xcT



s.t.
min*
z
compact formulation
A(m1  n)
D(m2  n)
Q(D, f) = {x  Rn | Dx > f}
Hp: Q(D,f ) is a non-empty polytope
Resolution Theorem (Weyl-Minkowski, 1936):
A point x belongs to Q(D,f ) if and only if it can be written as a
convex combination of the extreme points {v1,…,vq} of Q(D,f ) :
Q(D,f )  x = i ivi with i i = 1 and i > 0

Dantzig-Wolfe decomposition
qi
z
i
q
i
i
q
i
ii
q
i
iiDW










10
1
)(s.t.
)(min
1
1
1
*




bAv
vcT
extensive formulation
(master problem)
 Both formulations have the same optimal value: z*
DW = z*
 The extensive formulation (in variables ) has fewer constraints
(only m1+1) but a huge number of variables (order of )
Substituting for x in the
compact formulation we
obtain an equivalent






2m
n

Convexification of an integer program
n
z
Z
s.t.
min*




x
fDx
bAx
xcT
Q(D, f)
Q(D, f) = {x  Rn | Dx > f}
X = Q(D, f)  Zn
 Convexification (analogous of DW decomposition for IPs)
X = Q(D, f)  Zn = conv(X)  Zn

Q(D, f)
Convexification of an integer program
n
z
Z
s.t.
min*




x
fDx
bAx
xcT
conv(X)
 If conv(X)  Q(D,f) then the continuous relaxation of the
convexification is stronger than the continuous relaxation of the
original model.
n
C
Z
Xconv
z




x
x
bAx
xcT
)(
min*

An example
aTx = b
dTx = f
P = {aTx < b, dTx < f, x > 0, x  Z2}

aTx = b
dTx = f
P = {aTx < b, dTx < f, x > 0, x  Z2}
PR = {aTx < b, dTx < f, x > 0}
An example

dTx = f
X = {dTx < f, x > 0, x  Z2}
P = {aTx < b, dTx < f, x > 0, x  Z2}
PR = {aTx < b, dTx < f, x > 0}
An example

X = {dTx < f, x > 0, x  Z2}
P = {aTx < b, dTx < f, x > 0, x  Z2}
PR = {aTx < b, dTx < f, x > 0}
x  conv(X)
An example

aTx = b
X = {dTx < f, x > 0, x  Z2}
P = {aTx < b, dTx < f, x > 0, x  Z2}
PR = {aTx < b, dTx < f, x > 0}
x  conv(X)
PC = {aTx < b, x  conv(X) , x  Z2}
An example

Convexification and lagrangian relaxation
n
ZX
P


x
bAx
xcT
s.t.
min:
convexification
lagrangian relaxation provide the
same bound
lagrangian dual problem  )(minmax TT
bAxuxc
x0u

 X
L
 )(min)( TT
bAxuxcu
x

X
Llagrangian subproblem 0u ,
 )(minmax TT
)(
bAxuxc
x0u

 Xconv
L

Theorem of linear programming
 )(minmax TT
)(
bAxuxc
x0u

 Xconv
L
Reformulation of min
 )(minmax TT
bAvuvc
0u


kk
Kk
L
0u
bAvuvc



)(
max
TT
Kkt
tL
kk
index set of ext(conv(X))
0u
vcbAvu



)(
max
TT
Kkt
tL
kk
General form

Dual problem
0λ
λ1
0bAv
vc






1
)(
)(min
T
T
Kk
kk
Kk
kk
λ
λ
0u
vcbAvu



)(
max
TT
Kkt
tL
kk
lagrangian dual problem of P
Convexification of P

Discretization of an integer program
n
z
Z
s.t.
min*




x
fDx
bAx
xcT Q(D, f) = {x  Rn | Dx > f}
X = Q(D, f)  Zn
Theorem (Nemhauser-Wolsey, 1988):
X is generated by a finite number of integer points {p1,…,pq} of X
X  x = i ipi with i i = 1 and i {0,1}
Q(D, f)

discretization vs. convexification
PD = {aTx < b
x = i=1..8 ipi
i=1..8 i = 1
i  {0,1}
x  N2}
PD = {i=1..8aTpii < b
i=1..8 i = 1
i  {0,1}}
conv(X)
p1
p2
p3p4 p5
p6
p7
p8
aTx = b
Discretization: X  x = i ipi with i i = 1 and i {0,1}

PC = {aTx < b,
x = i=1..4 vii
i=1..4 i = 1
i > 0
x  N2}
PC = {i=1..4 aTvi i < b,
i=1..4 i = 1
i  N4}
conv(X)
v1
v2
v3v4 aTx = b
Convexification: X  x = i ivi , integer with i i = 1 and i  [0,1]

►Bounds: same polytope and therefore same bounds.
►Branching:
 convexification: must be performed on the original variables x
 discretization: can be performed directly on binary variables 
►Convexification and discretization are equivalent only when all
the original variables are binaries, i.e., when the set of integer
points of conv(X) corresponds to the set of extreme points of
conv(X).

Discretization of [KAN] model
}1,0{
integer,0
1
1
min
1
1
1
*











j
ij
j
n
i
iji
i
m
j
ij
m
j
j
y
x
mjLyxl
nidx
yz
Each of the m polyhedra corresponding to the pattern feasibility
constraints is discretized:
}1,0{
1
1
1







j
k
q
k
j
k
q
k
j
k
j
kij
j
j
x


p
mjLplX
n
i
ii
nj
,...,1N
1







 
p
qj = | X j |

Each of the m polyhedra corresponding to the pattern feasibility
constraints is discretized:
}1,0{
11
1)(
min
1
1 1
1 1
*








 
 
j
k
q
k
j
k
i
m
j
q
k
i
j
k
j
k
m
j
q
k
j
kD
mj
nid
z
j
j
j




p
}1,0{
integer,0
1
1
min
1
1
1
*











j
ij
j
n
i
iji
i
m
j
ij
m
j
j
y
x
mjLyxl
nidx
yz

}1,0{
11
1)(
min
1
1 1
1 1
*





 


 
 
j
k
q
k
j
k
i
q
k
m
j
j
kik
q
k
m
j
j
kD
mj
nid
z




p
Notice that X1 = ,…, = X m = X
pk m
kk pp ,...,1
and q1 =,...,= qm = qTherefore
replace with k > 0 integer
summation
m
m
j
q
k
j
k  1 1


qk
m
nid
z
k
q
k
k
i
q
k
kik
q
k
kD










1integer,0
1)(
min
1
1
1
*




p
0  X m
q
k
k 1

redundant constraint
at the end we obtain the [GG] model

CSP models relationship
mjLyxl
nidx
yz
j
n
i
iji
i
m
j
ij
m
j
jR









1
1
min
1
1
1
KAN
[KAN]
nkdx
Ljf
Lj
jf
xx
fz
k
Alii
lii
Akj
jk
Aji
ij
R
k
k
















1
1,...,10
0
min
),(
,
),(),(
deC
[deC]
nidxp i
N
j
jij 
1
1


N
j
jR xz
1
GG
min
[GG]
Discretization of
knapsack (fractional)
polyhedra
KANGG
RR zz 
Discretization of flow conservation
constraints (integer polyhedron)
deCGG
RR zz 

Solution methods:
Lower bounds

I1 = {i : li > L –  }

I2 = {i : L / 2 < li < L –  }
I3 = {i :  < li < L / 2}
L / 2



















 





L
dl
d
dd
z
IIi
ii
Ii
i
Ii
i
Ii
i
LB
)( 32
1
21
max)(

each part in I1 and I2 requires a distinct bin; parts in I3 are neglected
continuous lower bound of parts in I2 and I3

Solution methods:
heuristics

Primal heuristics
low: constructive heuristics
high: rounding of the fractional sol. of the continuous relaxation of [GG]
 First Fit Decreasing (FFD)
 Best Fit Decreasing (BFD)
 Sequential heuristics
Production volume (idi)
The number of operations
depends on the number of parts
 The number of operations does not depend on the demand
(is O(n2L) on average)
 Thanks to the IRUP property, the optimal solution approximates
the integer optimum as the demand gets larger

Low demand: on-line heuristics for BPP
 Next Fit (NF): the next item is assigned to the current bin if it has a sufficient
residual capacity, otherwise a new bin is open.
zNF := 1 and S := 0
for i := 1 to n do
if S + li > L then zNF := zNF + 1 and S := 0
pos(i) := zNF and S := S + li
end for

 [Theorem] zNF < 2li / L  1 < 2z*  1


]2,1[)(pos ii:
i Ll1:


]4,3[)(pos ii:
i Ll2:
 

],1[)(pos NFNF zzii:
i LlzNF/2:
li > L zNF /2
zNF < 2li / L
zNF < 2li / L
zNF < 2li / L  1
zNF < 2z*  1worst instance: {2, L  , 2, L  ,…}

 First Fit (FF): the next item is assigned to the bin with smallest index and
enough residual capacity. If there is none, a new bin is open.
for i := 1 to n do
pos(i) :=
end for
zFF := maxi=1,..,n pos(i)






 jh
ih
j
Lll
)(posIN
minarg

 Garey et al., 1976 zFF < 1.7 z*
 Simchi-Levi, 1994 zFF < 1.75 z*
 Asymptotic performance
 Absolute performance
 Boyar, 2012 zFF < 12/7 z*  1.7143 z*

Low demand: constructive heuristics
 First Fit Decreasing (FFD): sort the items in non-increasing order and apply FF.
 Best Fit Decreasing (BFD): sort the items in non-increasing order. Largest
unplaced item is assigned to the bin with smallest residual capacity, but still
sufficient to accommodate the item. If there is none, a new bin is open.
 FFD and BFD have:
 absolute performance zFFD < 3/2 z* (Simchi-Levi, 1994)
 asymptotic performance zFFD < 11/9 z* + 4 (Johnson, 1974)
zFFD < 11/9 z* + 3 (Baker, 1985)
zFFD < 11/9 z* + 1 (Yue, 1991)
zFFD < 11/9 z* + 2/3 (Dósa, 2007)
 If Successive Divisibility property holds then FFD is optimal (Coffman, 1987)

FFD: absolute performance
 [Theorem] (Simchi-Levi, 1994) zFFD < 3/2 z*
j = 2/3 zFFD
1
 1st case: the bin j contains an item k with lk > L/2
2
zFFD
 Consider the bin j = 2/3 zFFD
k
 bins i < j has no space for k
 Since items are sorted in non-increasing order,
bins i < j contains items with length > L/2
 At least j items has length > L/2
 z* > j > 2/3zFFD

FFD: absolute performance
 [Theorem] (Simchi-Levi, 1994) zFFD < 3/2 z*
j = 2/3 zFFD
1
zFFD
2
 Consider the bin j = 2/3 zFFD
 bins j, j + 1, …, zFFD contain at least 2(zFFD j) + 1
items
 2(zFFD j) + 1 > 2(zFFD 2/3 (zFFD +1)) + 1 =
2/3zFFD 1/3 > j  1
 Since, none of such (at least) j  1 items fits in the
first j  1 bins we have  li > L( j  1)
 z* >  li / L > j > 2/3zFFD
 2nd case: the bin j (and therefore the bins j +1,…, zFFD) contains no items
with length > L/2
worst instance: L = 10, l1 = l2 = 4, l3 = l4 = l5 = l6 = 3

FFD: asymptotic performance
L = 100
l1 = 51
l3 = 26
l2 = 27
d1 = 6
d2 = 6
d3 = 6
l4 = 23 d3 = 12
Optimal solution: 9 bins FFD solution: 11 bins

Low demand: constructive heuristics
 Sequential heuristics: a solution is built up pattern after pattern by solving a
sequence of integer knapsack problems. In general, sequential heuristics provide
much better solutions than FFD or BFD
while some parts are left do
 Solve the problem max{yTa | lTa < L, a  Nn}
 Cut mini:a > 0 d′i/ai stocks with the cutting pattern a
 Update the demands d′
end while
i
SVC (BelovScheithauer, 2007)
 



i ii
p
i
ii
al
lL
kyky 21
Fill Bin (Vanderbeck, 1999)
yi = li

High demand: [GG] rounding heuristics
Solve the residual problem
by FFD, BFD or by an exact
algorithm for BPP
x = solution of the
continuous relaxation of [GG]
 Column generation
y = Rounding of x
Residual demand = d  Ay
 round-up, round-down or a combination
of them
 Sequential rounding of the most fractional
variable (and fixing of integer variables)
 Removing of oversupply
Stadtler (1990), Waescher  Gau (1996),
Belov  Scheithauer (2002)
 Absolute performance: zH < z + n

[GG] rounding heuristic: performance
 [Theorem] (de la Vega - Lueker, 1981)
Let x be a basic solution (non necessarily optimal) of the continuous
relaxation of [GG]. A solution xH of CSP with
zH < z + (n  1)/2
cuts can be always obtained.
[proof]
 x  = round-down of x and x = round-up of x
 R = residual instance and SUM(R) = iR li
► Solution of R
1) x  x is a solution of R with at most n cuts (x is a FBS)
2) Next Fit solves R with at most 2 SUM(R)/L  1 cuts

[GG] rounding heuristic: performance (cont’d)
► By combining 1) and 2), the number of required cuts is
zR = min{n, 2 SUM(R)/L  1} < (n  1)/2 + SUM(R)/L
min{a,b} < mean(a,b)
  R
N
j
jH zxz  1
    







N
j
n
i
iijjj lp
L
xx
1 1
1
  

N
j
jj xx
1
     





 

N
j
jj
N
j
jH xx
n
xz
11 2
1






 

N
j
jx
n
12
1
 z
n





 

2
1











 

L
RSUMn )(
2
1

Solution of [GG]: column generation
Several problems (cutting stock, crew scheduling, clustering,…)
admit a natural formulation with exponentially many variables.
 For such integer programs, even the continuous relaxation can be
hard to solve. Indeed, it is already impractical to write down the
program: the [GG] model has 50 constraints and much more than
250 (i.e., 1.125.899.906.842.624) variables for an instance with 50
part types.

Col Gen: the restricted master problem
 [Idea] we solve a restricted version of [MP] (the Restricted Master Problem
[RMP]) defined on a subset R of A and we dynamically generate only the
columns of A that are part of the optimal solution or that guide the search toward
the optimal solution.
master problem [MP] z*
R = min{cTx: Ax = b, x > 0} A(n  N), x  RN
 [Observation] an optimal solution is an FBS (Feasible Base Solution): regardless
the number N of variables, it has at most n << N non-zero components.

Col Gen: the algorithm
while there exists a column Aj in A R with negative reduced cost do
 Add the column Aj to the matrix R
 Solve the new Restricted Master Problem
end while
The optimal solution of [RMP] is the optimal solution of [MP]
 Explicit scan of A R is impractical.
 If the mathematical structure of columns is known, a new optimization problem
(pricing problem) that computes the most attractive column of A R, i.e., that with
minimum reduced cost, can be defined.

Col Gen: pricing problem
Restricted Master Problem
zR = min{cRxR | RxR = b, xR > 0}
Pricing Problem
* = min{cj  TAj | Aj  AR}
dual variables 
attractive column Aj
* < 0
* > 0
END
(xR, 0N r)
optimal solution
 (xR, 0N r) is feasible for [MP]
 If * > 0 then  is feasible for the dual of [MP].
 zR = Tb and therefore (xR, 0N r) is optimal for [MP] (strong duality)
The efficiency of column generation strictly depends on
the complexity of the pricing problem

Column generation for [GG] model
 The continuous relaxation of [GG] model is:
Let yi be the number of parts of type i in a column (cols of A are cutting patterns)
[GGR] z*
R = min{1Tx: Ax > d, x > 0} A(n  N), x  RN
01
1
 
n
i
ii y The column is an attractive cutting pattern if
Lyl
n
i
ii 1
 The column is a feasible cutting pattern if






  
integer,0,1min
11
*
i
n
i
ii
n
i
ii yLylyPricing Problem:

Column generation for [GG] model
 The pricing problem is a (bounded) integer knapsack
 solved by:
 dynamic programming in O(nL)
 branch-and-bound: (Pisinger, MartelloToth, HorowitzSahni)






  
integer,0,1min
11
*
i
n
i
ii
n
i
ii yLylyPricing Problem:






  
integer,0,max1
11
*
i
n
i
ii
n
i
ii yLyly


An example
L = 8
l1 = 4
l3 = 2
l2 = 3
d1 = 5
d2 = 4
d3 = 8
 A starting feasible solution (required to provide starting duals) can be easily
obtained by considering a maximal cutting pattern for each part type:











0
0
2
1p











0
2
0
2p











4
0
0
3p

An example: 1st iteration
zR = min x1 + x2 + x3
2x1  5
2x2  4
4x3  8
x1 x2 x3 > 0
 First restricted master problem on patterns p1, p2 e p3 :
 The optimal solution is xR = (2.5, 2.0, 2.0)
and its value is zR = 6.5. The corresponding
dual solution is  = (0.5, 0.5, 0.25)
 The pricing problem is:
* = 1  max{0.5 y1 + 0.5 y2 + 0.25 y3 | 4 y1 + 3 y2 + 2 y3 < 8, y1 y2 y3  N}
The optimal solution is y = (0, 2, 1) with * = 0.25: the cutting pattern A = (0, 2, 1)
has a negative reduced cost and hence is a candidate for entering in the basis of the
restricted master problem.

An example: 2nd iteration
zR = min x1 + x2 + x3 + x4
2x1  5
2x2 + 2x4  4
4x3 + x4  8
x1 x2 x3 > 0
 The new restricted master problem is:
 The optimal solution is xR = (2.5, 0.0, 1.5, 2.0)
dual solution is  = (0.5, 0.375, 0.25)
 The pricing problem is:
* = 1  max{0.5 y1 + 0.375 y2 + 0.25 y3 | 4 y1 + 3 y2 + 2 y3 < 8, y1 y2 y3  N}
The optimal solution is y = (2, 0, 0) with * = 0.0: there are no cutting patterns with
negative reduced cost, therefore xR = (2.5, 0.0, 1.5, 2.0) is an optimal solution of the
continuous relaxation of [GG] model.

Solution methods:
back to
approximation results

Asymptotically exact algorithms
 de la Vega – Lueker, 1981
zH < (1+)z* + 1/2 0 <  < 1/2
 Jansen – Solis-Oba, 2011
zH < z* + 1 in O((log2 ∑di + log L)3 log5 ∑di)
for fixed number of part-types
 Karmarkar – Karp, 1982
zH < z* + O(log 2 n) AFPTAS

de la Vega  Lueker, 1981
 0 <  < 1/2
Km1K0 K1 Km2 RF
 = L /( + 1)
L/2
|K0| < h1 |K1| = … …= |Km2| = |Km1| = |R| = h – 1
ym
ym1
ym2
y2
y1

 Let
 M = K0  K1  …  Km1
 Q = {y1, …, y1, y2, …, y2,…, ym, …, ym}
h1 h1 h1
CSP instance with m part-types
 0 <  < 1/2
 = L /( + 1)
F K0 K1 Km2 Km1 R
L/2
|K0| < h1 |K1| = … …= |Km2| = |Km1| = |R| = h – 1
ym
ym1
ym2
y2
y1

 Clearly z*
Q < z*
 Compute by [GG] a packing of Q with zQ < z*
Q + (m  1)/2.
The number of cutting patterns is a constant N = O(mL/) therefore [GG] can be
solved in polynomial time (Lenstra, 1983)
 0 <  < 1/2
 = L /( + 1)
L/2
|K0| < h1 |K1| = … …= |Km2| = |Km1| = |R| = h – 1
ym
ym1
ym2
y2
y1

 0 <  < 1/2
 = L /( + 1)
L/2
1) Since |R| = |Km1| = …= |K1| > |K0| and ym > l l  Km1 , … , y1 > l l  K0
a packing of M can be easily obtained from a packing of Q, hence zM = zQ
2) Moreover, parts in R can be packed in |R| bins, hence zR = h – 1
3) Pack F in the bins used for packing M and R (by any heuristic, e.g. FF)
4) Pack F´ (the residual of F after step 3.) by Next Fit

 Case 1: F´  
since l < , l  F, each bin is filled for at least L   (except possibly the
last)
*
1
)1)(( LzlzL
n
i
iH  

1
1 *


 Lz
L
zH

2
** 1
)1(1)1(

  zzzH
 = L /( + 1)







 
n
i
ilh
1






 

h
Fn
Lm
||
 Case 2: F´ = 
Let zH <
2
1** 

m
zz
2
1
)1( * 

m
z
  2
11







 L
Fn
Fn
L
zH <
2
2
*
2
1
)1(




 z




 n
i
il
Fn
L
h
Fn
L
1

2
* 1
)1(

  z
zH = zM + zR   1
2
1*





 
 h
m
z

Jansen – Solis-Oba, 2011
 Split the instance into big and small parts L = 100
 big parts B = {i | li > L}
 small parts S = {i | li < L}12
1


n

L = 14.28
l1 = 35
l2 = 25
l3 = 12
l4 = 9
 Split each pattern into a big and a small sub-pattern
p
pB pS
 PB = set of big sub-patterns (including the empty subpattern)
 PS = set of small sub-patterns

N












ji
i
Pj
jij
i
Pj
jij
Pj
j
B
jj
i
i
yx
Sidxp
Bidy
zy
Pjyx
j
B
j
B
j
j
B
i
,
:
:
:
*
:
:
p
σ
σ
σp
σ

[GGD]: activation level of big sub-patterns
The total number of cuts must be z*
big parts must be covered by big
sub-patterns
small parts must be covered
 [Proposition] The solution x is optimal for [GG] if and only if (x, y) is feasible
for [GGD]

 the formulation [GG] always admits an optimal solution x with at most 2n
activated cutting patterns (EisenbrandShmonin, 2005).
Relax the integrality constraints
Choose < diz
Choose a set of 2n big sub-patternsPB
 B
PzMILP ,
z
PB
PB
PB
xi > 0N












j
i
j
jij
i
j
jij
j
j
jj
i
i
y
Sidxp
Bidy
y
jyx
B
j
j
j
j
B
i
:
:
:
:
:
p
σ
σ
σp
σ

PB

 [Remark] has a constant number (2n) of integer variables but an
exponential number, |P| = O((di)n), of continuous variables.
 B
PzMILP ,
 Solvable in polynomial time by the Lenstra’s algorithm and the ellipsoid method
where the separation oracle is a knapsack with a constant number of variables.
 Let (x*, y*) a solution of MILP(z*, PB*)
 Integer variables y* describe an assignment of big parts to z* stocks
 Continuous variables x* describe a fractional assignment of small parts
 [Theorem] All the small parts can be assigned by using at most one additional
stock

any optimal solution x´ has at most
Y + n positive variables
*
:
**
:
:
:0
:
min
*
BB
jj
i
Pj
jij
B
jj
i
i
Pj
j
Pjx
Sidxp
Pjyx
x
BB
j
j
B
i
j









p
σ
p
σp
p
small parts assignment
Y + n positive variables for Y constraints
 at least Y  n are integer
Y constraints (one for each positive yj
* )
at most n constraints
< 2n fractional variables

   12  nxx ii
 the unpacked small parts require at most stocks
 Apply Next Fit algorithm to 2n – 1 stocks of the solution (those without small
parts) in order to assign such small parts. At the end of the procedure:
 all the small parts have been assigned to stocks. We have done
 some small parts still have to be assigned
the residual of the 2n – 1 stocks is at most (2n – 1) L = (2n – 1)L /(2n – 1)
the residual small parts require at most one additional stock

Set  = 1/(2n – 1) and z* = di
For each set of 2n
big sub-patterns
PB
Find = min{1,2,…,z*} such that
has a solution (x*, y*) B
PzMILP ,
z
Update z*
Rounding of (x*, y*) with at most
one additional stock
O(log(di)) MILP
(binary search)
 








n
n
2
/1 
times

Solution methods:
exact algorithms
Solution of [GG] by means of
column generation + implicit enumeration

Literature
 1996 – P. H. Vance, “Branch-and-price algorithms for the one-dimensional
cutting stock problem”, Computational Optimization and Applications (n < 20)
 1998 – J. M. de Carvalho, “Exact solution of cutting stock problems using column
generation and branch-and-bound”, International Transactions in Operational
Research
 1999 – F. Vanderbeck, Computational study of a column generation algorithm
for bin packing and cutting stock problems, Mathematical Programming (n < 50)
 2006 – G. Belov and G. Scheithauer, “A branch-and-cut-and-price algorithm for
one-dimensional stock cutting and two-dimensional two-stage cutting”, European
Journal of Operational Research
 2008 – C. Alves, J. M. de Carvalho, “A stabilized branch-and-price-and-cut
algorithm for the multiple length cutting stock problem”, Computers &
Operations Research (n < 100 and 4 stock sizes)

Branch-and-Price
 Master problem initialization
 Master problem solution
 Node selection strategies
 Branching

Master problem initialization
Initialization for CSP
 A maximal cutting pattern for each part-type (Vance, De Carvalho)
 A unique super-pattern with bigM coeff. in the o.f. (Degraeve, Vanderbeck)
 Primal solutions computed by FFD, BFD and Fill Bin heuristics (Vanderbeck)
 Feasibility of the master problem must be guaranteed at each node of the
enumeration tree.
 Irrelevant or poorly chosen initial columns may cause the heading-in effect
(Vanderbeck, 2005)

Master problem solution
 Complexity: an LP model with an exponential number of
variables is polynomially solvable by column generation if and
only if the pricing problem is polynomial.
 Algorithms: simplex, dual simplex, subgradient, hybrid
methods simplex-subgradient (Barahona  Jensen, 1998
Degraeve  Peeters, 2003).
 Running time: tailing-off effect
(slow convergence and degeneracy)

Master problem solution: tailing-off
iterations
*
Rz
master problem
solutions zR
lower bound zL
 The number of iterations can be reduced by:
 interrupting the generation of columns (early termination)
 increasing the convergence speed (acceleration techniques)

Early termination: lower bound’s lower bound
 Let A* be the column with minimum reduced cost
1  TA* < 1  TAj for any column j
TAj < TA*
TAj / TA* < 1
( / TA*)TAj < 1
dual feasible solution
the corresponding value Tb / TA* is a lower bound to z*
R
optimal solution zR of the
current master problem
optimal solution * of
the pricing problem

Early termination: lower bound’s lower bound
*
* R
R
L z
z
z 







 If zL = zR then early termination (because z*
R = zR )
 If zL > zU then pruning for bounding
 [Remark] the bound zL is not monotone throughout the column generation
 (Farley, 1990) a lower bound zL of the master problem optimal value z*
R is:
master problem current value
current pricing optimal value

Acceleration techniques
General methods:
 Trust region (Madsen, 1975): box constraints on dual variables
 Stabilization (Ben Amor 2002, Du Merle et al. 1999): perturbation of RHS by
means of surplus and slack variables and penalization of their usage
Problem specific methods:
 Dual cuts (de Carvalho, 2000) adding of valid dual cuts to the master problem
before starting column generation
 Slow convergence is mainly due to the oscillation of dual variable values
throughout the column generation.
 The bounding of the dual space speeds-up the convergence

Acceleration techniques: stabilization
0x
bAx
xc


min T
 Add surplus and slack variables y and y+
 Variables y and y+ account for a perturbation of
b by  [, +] helping to reduce degeneracy
 The perturbation is penalized by  and +
+ 
Ty + +
Ty+
 y+ + y
y [0, ]
y+ [0, +]
An optimal solution of the perturbed problem is an optimal solution of the
original problem when the best reduced cost is > 0 and y+ = y = 0
 Select starting value of  to form a box containing an estimated dual solution
 Solve the model.
 If the new dual u is in the box [, +] reduce its size and increase the penalty ,
otherwise enlarge the box and decrease the penalty.

Acceleration techniques: stabilization
0ww
wδuwδ
cuA
wεwεub







,
max
T
TTT
 Dual perspective
 Dual variables u are restricted to the box
[, +]
 the deviation w or w+ of u from the box is
penalized by  and + respectively.

Dual cuts
 A dual cut is an inequality that cuts the dual space. From the primal point of view, a
dual cut is a new variable u :
extended master problem [MPE]
0ux
bDuAx
udx1



,
min TT*
REz
 [Theorem] an optimal solution for [MP] can be obtained from any optimal
solution of [MPE] If there exists a map between solutions of [MPE] and [MP]
that preserves the value of the objective function.
hence, in general, [MPE] is a relaxation of
the master problem [MP], but
restricting the dual  relaxing the primal
 We are interested in dual cuts that preserve at least one optimal dual solution

Dual cuts for CSP
For each part-type i and for each set S  Si = {s | ls < li} one has:
i
Ss
s  
0 Ss
si  is a dual cut
 [primal interpretation] a produced part of length li can be used for producing
(at zero cost) a set of parts whose total length is no greater than li
[Property] Let 1, 2 ,…,n be the dual variables of [GG]. If l1 < l2 <…< ln then
1 < 2 <…< n for any optimal solution.
i
Ss
s ll 


An example
[Instance] L = 9, n = 2, l = (2,3) d = (d1,d2)
z* = min 1x1 + 1x2 + 1x3 + 1x4
4x1+ 3x2+ 1x3  d1
1x2+ 2x3+ 3x4  d2
x1 x2 x3 x4 > 0
[Primal]
w* = max d11 + d22
4 1 < 1
31 + 12 < 1
11 + 22 < 1
32 < 1
1 , 2 > 0
[Dual]
[Pricing] {y  N2 | 2y1+3y2 < 9}
Dual space
1
2
41 = 1
11 + 22=1
31 + 2=1
32 = 1
 2 + 1 < 0
Dual cut

From a solution of [MPE] to a solution of [MP]
L = 20
l1 = 3
l2 = 4
l3 = 5
l4 = 7
l5 = 8
2
0
0
2
0
pattern p
xp = 0.3
1
1
0
-1
0
+
dual cut u
u = 0.5 z = 0.3
=
1.1
0.5
0
0.1
0
2
0
0
2
0
pattern p
xp = 0.05
4
2
0
0
0
+
pattern q
xq = 0.25 z = 0.3
=
1.1
0.5
0
0.1
0

From a solution of [MPE] to a solution of [MP]
0 3 6 7 13 20
0.5 0.5
0.5
0.05 0.05 0.05 0.05
0.3
2
0
0
2
0
p
0 3 6 9 1613 20
0.25 0.25 0.25 0.25 0.25 0.25
 A dual cut is a cycle where the longest edge is traversed backward
 cycles can be combined with paths in order to produce new paths
0.3 0.3 0.3 0.3
0.3
2
0
0
2
0
p
1
1
0
-1
0
u
4
2
0
0
0
q

Dual cuts for CSP
 Dual cuts are exponentially many.
 De Carvalho uses only those with | S | < 2
 i + i + 1 < 0 i = 1,…, n – 1
 i + j + k < 0 i, j, k : lj + lk < li
Results:
 Beasley, BPP instances: reduction in number of columns (43%) and in running
time (20%).
 Vance, CSP instances: reduction in number of columns (76%), in running time
(78%) and in degenerate pivot (from 39.8% to 8.5%).
 Belov, Multiple Lenght CSP instances: reduction in number of branch-and-
bound nodes (70%) and in running time (50%)

Node selection strategies
 The optimal value of IRUP instances is already known
at the root node.
 non-IRUP instances are uncommon.
 The problem admits a lot of equivalent optimal solutions
Depth-first search

Branching
 A valid branching rule must
 cut the current fractional solution,
 ensure the finiteness of the algorithm.
 A good branching rule should
 keep the search space balanced,
 preserve the structure of the pricing problem (robustness).
branching rule for CSP
 Dichotomy on variables of the pattern-based model (Belov, Degraeve)
 Generalization of the Ryan-Foster rule (Vance)
 General scheme (Vanderbeck)
 Dichotomy on variables of the arc-flow model (de Carvalho)

Branching: dichotomy on pattern variables
 *
jj xx 
  1*
 jj xx
 Easy to implement (by setting bounds on variable) but produces an unbalanced
enumeration tree (up-branching corresponds to a very small sub-tree)
 up-branching does not destroy the structure of the pricing problem (the up-
branching node corresponds to a residual CSP)
 A variable with upper bound (set by down-branching) may correspond to the
most attractive column generated by the pricing problem. Pricing problem
turns out to be a k-knapsack problem.
*
jx
down-branching
up-branching

Ryan-Foster’s branching rule
Branching rule for the set-partitioning ILP (and for BPP)
min{cTx: Ax = 1, x {0,1}}
10
1:
   skrk aak
kx
same column1
1:
  skrk aak
kx
different columns0
1:
  skrk aak
kx
 For any fractional solution x one can always identify two rows r and s such that:
 Same column: rows r and s must be covered by the same column
 Different columns: rows r and s must be covered by different columns

Ryan-Foster’s branching rule: example
0 1 0 1 0 1 1 1 0 0 0 0
1 1 0 0 1 0 0 0 1 0 0 0
1 0 1 1 0 0 1 0 0 1 0 0
0 0 0 1 1 1 1 0 0 0 1 0
1 1 1 0 1 0 1 0 0 0 1 1
= 1
= 1
= 1
= 1
= 1
0.3 0.3 0 0.7 0.3 0 0 0 0 0 0 0
x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12
r
s
0 1
1 1
0 1 1 0 0 0
1 0 0 1 0 0
0 1 0 0 1 0
1 1 0 0 0 1
1 1 0 0 0 1
x5 x7 x8 x9 x10 x11
1
1: 54
  kk aak
kx
0 1 0 1 1 1 0 0 0
1 1 0 0 0 0 1 0 0
1 0 1 1 0 0 0 1 0
0 0 0 1 1 0 0 0 0
1 1 1 0 0 0 0 0 1
x1 x2 x3 x4 x6 x8 x9 x10 x12
0
1: 54
kx
x =
same rows:
smaller problem
disjoint rows:
easier problem

Ryan-Foster’s branching rule: pricing
0 1 1 0 0 0
1 0 0 1 0 0
0 1 0 0 1 0
1 1 0 0 0 1
1 1 0 0 0 1
x5 x7 x8 x9 x10 x11
0 1 0 1 1 1 0 0 0
1 1 0 0 0 0 1 0 0
1 0 1 1 0 0 0 1 0
0 0 0 1 1 0 0 0 0
1 1 1 0 0 0 0 0 1
x1 x2 x3 x4 x6 x8 x9 x10 x12
1
1: 54
kx
0
1: 54
kx
r
s
duals
1
2
3
r
s
c  max{Ty | (y1 y2 y3 1 1)  feas. cols.)
pricing
c  max{Ty | (y1 y2 y3 yr ys)  feas. cols.
and yr + ys < 1 }
r
s

Ryan-Foster’s branching rule: correctness
►[Theorem] Ryan-Foster (1981)
For any fractional feasible basic solution x there always exists two rows r and
s such that:
10
1:
   skrk aak
kx
[proof]
►Suppose xi fractional and select row r such that ari = 1
(a such row always exists)
►Since ar
Tx = 1 and xi fractional, there must exist some
other basic column j such that 0 < xj < 1 and arj = 1.
►Since there are no duplicate columns in the basis, there
must exist some row s such that asi = 1 or asj = 1 but not
both.
 

1:1:
1
skrkrk aak
k
ak
k xx
xj
1
1 = 1……s 0…
… …… = 1
xi
r 1

Branching: generalization of Ryan-Foster
 For any fractional solution x* one can always identify a sub-pattern S (i.e. a
set of rows S (branching set) and a set of integers {i, i  S}) such that:
S
j
j
SSj
x αa:
*
down-branching S
j
j
SSj
x αa:
*
 Summation boils down to one (fractional) variable x*
k if the master problem
consists of only maximal cutting patterns and one chooses S = ak
up-branching  1
:
*

S
j
j
SSj
x 
αa
fractional
branching dichotomy on pattern variables

Branching: general scheme
 matrix A of the master problem is converted into a matrix Ab whose columns are
the binary encode of the columns of A.
 For any fractional solution x* one can always identify a sub-pattern S (i.e., a set
of rows S of Ab and a vector of bits {i, i  S}) such that:
 If S = [1] the pricing problem remains a binary knapsack
down-branching S
j
j
SSj
x 
αab
:
*
up-branching  1
b
:
*


S
j
j
SSj
x 
αa
S
j
j
SSj
x 
αab
:
*
fractional

Branching: dichotomy on arc-flow variables
Our most valuable source of information are the original
variables of the compact formulation; they must be integer, and
they are what we branch and cut on
(Lübbecke  Desrosiers, 2005)
Solve [GG] model but branch on
arc-flow variables of [deC] model

 For any solution x* of [GG] one can always obtain a solution y* of [deC].
In particular, the flow yij on edge (i, j) is:


Pk
kij xy ** P′ = set of cutting patterns
with part-type of length j – i
in position i
Branching dichotomy on
arc-flow variables
*
ijy
 *
ijy  1*
 ijy
Branching constraints on
[GG] model
*
ijy
 Pk
kx*
  1*


Pk
kx

robust branch-and-price
 Branching constraints do not change
the structure of the pricing problem
(max path on acyclic graph)
 j jR xz minGG
[GG] constraintsnidxp ij jij  1
Branching constraints
  UpBklx klklj j
j
 
),(1),(),(:
p
  DwBklx klklj j
j
 
),(),(),(:
p
Duals
i :
lk :
lk :
 In the pricing problem, the cost of edge (l, k) with k  l = i is
 

UpBkl
lk
DwBkl
lkilkc
),(),(


An example
L = 8
l1 = 4
l3 = 2
l2 = 3
d1 = 5
d2 = 4
d3 = 8











0
0
2
1p











0
2
0
2p











4
0
0
3p
zR = min x1 + x2 + x3 + x4
2x1  5
2x2 + 2x4  4
4x3 + x4  8
x1 x2 x3 > 0
 The optimal solution is xR = (2.5, 0.0, 1.5, 2.0)
dual solution is  = (0.5, 0.375, 0.25)











1
2
0
4p

An example
0 2 31 4 5 6 87
2.5
2.5
1.5 1.5 1.5 1.5
2 2
2
 Also y02 , y04 , y24 , y46 and y48 are candidate branching variables










0
0
2










0
2
0










4
0
0
2.5 0.0 1.5 2.0










1
2
0
y68 = 2 + 1.5 = 3.5
y68 > 4y68 < 3
Branching arc-flow variable
x3 + x4 = 3.5
x3 + x4 > 4x3 + x4 < 3
Branching constraints on [GG] model

Research directions
Theoretical issues
 Is CSP polynomial for each given n? yes
 Is MIRUP property true?
Algorithmic and application issues
 Solution of non-IRUP instances
 Problem extension (multiple lengths, technological
constraints, integration with scheduling issues)

Some other references
 2002 – C. Arbib, F. Di Iorio, F. Marinelli, F. Rossi, “Cutting and Reusing: an Application
from Automobile Component Manufacturing”, Operations Research
 2005 – C. Arbib, F. Marinelli, “Integrating Process Optimization and Inventory Planning
in Cutting-Stock with Skiving Option: an Optimization Model and its Application”,
European Journal of Operational Research
 2007 – C. Arbib, F. Marinelli, “An Optimization Model for Trim Loss Minimization in an
Automotive Glass Plant”, European Journal of Operational Research
 2009 – C. Arbib, F. Marinelli, “Exact and Asymptotically Exact Solutions for a Class of
Assortment Problems”, INFORMS Journal on Computing
 2011 – A. Aloisio, C. Arbib, F. Marinelli “On LP Relaxations for the Pattern
Minimization Problem”, Networks
 2011 – A. Aloisio, C. Arbib, F. Marinelli, “Cutting Stock with No Three Parts per Pattern:
Work-in-process and Pattern Minimization”, Discrete Optimization
 2012 – C. Arbib, F. Marinelli, F. Pezzella, “An LP-based tabu search for batch scheduling
in a cutting process with finite buffers”, International Journal of Production Economics

models and algorithms for
one-dimensional cutting problems
Fabrizio Marinelli
fabrizio.marinelli@univpm.it
Università Tor Vergata
Roma, November 2013

One-dimensional cutting problems: models and algorithms

More Related Content

Viewers also liked

Similar to One-dimensional cutting problems: models and algorithms

Recently uploaded

One-dimensional cutting problems: models and algorithms