Planning of a make-to-order production process in the printing industry

Abstract

Offset printing is a common method to produce large amounts of printed matter. We consider a real-world offset printing process that is used to imprint customer-specific designs on napkin pouches. The production equipment used gives rise to various technological constraints. The planning problem consists of allocating designs to printing-plate slots such that the given customer demand for each design is fulfilled, all technological and organizational constraints are met and the total overproduction and setup costs are minimized. We formulate this planning problem as a mixed-binary linear program, and we develop a multi-pass matching-based savings heuristic. We report computational results for a set of problem instances devised from real-world data.

1 Introduction

In many economic sectors, small and medium enterprises (SMEs) are the primary drivers of innovation and competition. For SMEs in the manufacturing sectors, efficient utilization of the production equipment is particularly important for staying globally competitive. The problem discussed in this paper was reported to us by an SME that operates in the printing industry.

The company uses an offset printing process for manufacturing napkin pouches; a significant fraction of the demand is for pouches with customer-specific designs, which are manufactured make-to-order, whereas the remainder is for pouches with standard designs, which are manufactured make-to-stock. Both types of designs are imprinted on the pouches by offsetting the respective inked image from some rotating printing plates to the surface of some paper; afterwards, the pouches are produced by cutting, folding and gluing this paper. The printing plates used here include seven slots; an individual design is allocated to each slot. The planning problem involves determining the number of required printing plates, the allocation of the designs to the slots of these plates, and the number of rotations of each plate such that a given demand for each design is fulfilled, all technological constraints are met, and the total costs are minimized. These costs comprise (a) overproduction costs, which arise when the production quantity of a design exceeds the given demand, and (b) setup costs, which arise for each printing plate that is used. Currently, this problem is solved manually using a time-consuming, spreadsheet-based approach; further drawbacks of this approach are the potential risk of inefficient utilization of the production equipment and of infeasible plans.

To the best of our knowledge, this problem has not yet been discussed in the literature. Related planning problems known from the literature are the job-splitting problem, the layout problem, and the cover-printing problem. Compared to these problems, however, the production process discussed in the present paper comprises various additional technological constraints which increase the complexity of the planning problem.

The contribution of this paper is twofold. First, we formulate the problem as a mixed-binary linear program. To render this optimization problem computationally tractable at least for small-sized instances, we enhance the problem formulation by using constraints that eliminate three different types of symmetries from the search space. Second, we propose a heuristic approach for medium- and large-sized instances. This heuristic is inspired by the well-known savings algorithm of Clarke and Wright (1964) for the vehicle routing problem: in the initial solution of the heuristic, one plate is set up for each design; these plates are then successively merged, where the savings associated with such a merger are devised from the economized setup-cost and the additional overproduction cost. Similar to the heuristics proposed in Altinkemer and Gavish (1991) and Wark and Holt (1994), our heuristic uses repeated matching, i.e., in each iteration of the heuristic, several pairs of plates are merged simultaneously. Eventually, a local-search improvement procedure is applied to the resulting solution. We implement this heuristic as a multi-pass procedure, in which in each pass, the matching problem for identifying the pairs of plates to be merged is varied.

To evaluate the performance of the proposed model formulation and the proposed heuristic, we have generated a set of instances based on the original data provided by the company. Using standard optimization software, the model formulation can be used to determine optimal solutions for small-sized instances within reasonable CPU times. Moreover, the heuristic computes optimal solutions for all small-sized instances and provides good feasible solutions for medium- and large-sized instances.

The remainder of this paper is organized as follows. In Sect. 2, we describe the planning problem in detail. In Sect. 3, we review the related literature. In Sect. 4, we present the formulation as a mixed-binary linear program and the symmetry-breaking constraints. In Sect. 5, we describe the savings heuristic and its implementation as a multi-pass matching-based procedure. In Sect. 6, we report the design and the results of the computational analysis. In Sect. 7, we close the paper with some concluding remarks and directions for future research.

2 Planning situation

In Sect. 2.1, we describe the real-world planning problem to be solved. In Sect. 2.2, we present an illustrative example.

2.1 Planning problem

In offset printing, the image to be printed is indirectly transferred from a metal printing plate to the paper. In general, one printing plate is required for each primary color, and one for black color. The plates are chemically treated such that the ink adheres to specific areas of the plate only. By rotating the plate, the image is first transferred to a rubber cylinder that in turn transfers the image onto the paper as it passes below; the term offset refers to the fact that the image is not printed directly on the paper but on another surface that then makes contact with the paper. In relation to the variable cost, the production and setup costs of the printing plates are relatively high. Therefore, offset printing is best suited for producing large amounts of high-quality printed matter. Typical applications include newspapers, magazines and books. The company involved uses the offset-printing technology to produce napkin pouches.

Each week, a set of customer orders is given, each consisting of a customer-specific design (with or without a white border), a napkin color, and a demand. In typical problem instances of the company mentioned above, between 50 and 90 different customer-specific designs are to be planned. The company concentrates on customer-specific designs; therefore no demand for standard designs is given here, but these designs are produced in separate batches.

In the following, we refer to a set of four printing plates (one for each primary color and one for black) as a single plate. The planning problem discussed in this paper is to determine (1) the number of printing plates to be used; (2) the allocation of the ordered designs to the slots of these plates; and (3) the number of rotations of each plate. The objective is to minimize the total costs, which comprise (a) overproduction costs, which arise when the production quantity of a design exceeds the given demand; and (b) setup costs, which arise for each printing plate that is used. Basically, the constraints of the planning problem are that the given demand for each design must be fulfilled and that the allocation of the designs to the plates must be feasible with respect to the technology and the organization of the shop floor. In detail, the latter can be divided into the following constraints.

• 1. Plate constraint The number of different designs that can be printed using the same plate depends on the size of the plate and the size of the napkin pouches. Here, all pouches have the same size, and a plate comprises seven slots, i.e., at most, seven different designs can be produced using the same plate. It is not possible to leave a slot empty. The number of produced units for a specific design depends on the number of slots allocated to this design and on the number of plate rotations. Whenever a new printing plate is used, setup costs are incurred; these costs include production, cleaning, and installation costs. Note that before and after the respective quantities are imprinted, the plates perform some additional rotations in order to reach the required speed and to stop, respectively; therefore, we assume that the number of plate rotations may be non-integer.

• 2. White-border constraint When the printing plate is wrapped around the cylinder, a small gap between the plate borders arises due to technological reasons. This gap leads to a white stripe on the paper. Therefore, at least two slots on the plate must be occupied by a design that has a white border. Alternatively it is possible to avoid the white stripe by assigning a standard design to one slot. Standard designs use one color only and are printed with an additional fifth cylinder that requires no setup. By rotating the fifth cylinder out of phase, the white stripe is overprinted. It is not feasible to allocate more than one standard design to a plate. A standard design exists for each napkin color.

• 3. Color constraint After printing, the paper is cut, folded and glued. Finally, the napkins are inserted into the resulting pouches using a process-specific machine; this machine can insert napkins of at most two different colors simultaneously. Therefore, a plate must not contain designs with more than two different napkin colors.

• 4. Split constraint The packing of the pouches into the boxes used for delivery imposes an organizational constraint. If a design were allocated to two or more plates (i.e., the order would be split among several plates), then the packing would require significantly more space in the limited packing area and more manpower. Therefore, each design must be allocated to a single plate.

2.2 Illustrative example

We illustrate the planning problem with an example with three customer orders (cf. Table 1). The setup cost per plate is €540 and the overproduction cost per unit of a standard design is €0.001. Due to the color constraint, at least two printing plates are required to fulfill the demand.

Table 1 Input data of illustrative example

Figure 1 shows an optimal solution to the illustrative example.

Fig. 1

Optimal solution to the illustrative example

In this solution, a standard design is allocated to plate B to satisfy the white-border constraint. The number of produced units can be computed by multiplying the number of allocated slots times the corresponding number of rotations of plate $p$ ($R^p$). In the solution shown in Fig. 1, overproduction costs of €5.83 for the standard design on Plate B occur. The total costs of this solution of €1,085.83 comprise setup costs of €540 for each plate and total overproduction costs of €5.83.

3 Literature review

In this section, we review the literature on problems that are closely related to the planning problem presented in Sect. 2. In particular, we refer to the so-called job-splitting, the layout, and the cover-printing problem, respectively.

The planning problem discussed in this paper can be interpreted as an extension of the job splitting problem (JSP), which we summarize as follows. Given quantities of $n$ products must be produced on a machine with $m$ slots. A particular assignment of a set of jobs to the slots is called a run and requires a setup. The length of a run determines the quantity produced in each slot during that run. The objective is to find a set of runs that minimizes the total setup and overproduction costs. The JSP relates to the planning problem discussed in the present paper as follows. The machine corresponds to a printing plate, the number of slots on the machine corresponds to the number of slots available on the plate, the different types correspond to the different designs, and the run length corresponds to the number of plate rotations. However, the JSP does not include neither the white-border nor the color constraint. Ekici et al. (2010) prove that the JSP is strongly NP-hard, and present a non-linear integer programming formulation, two linear integer programming formulations with some preprocessing steps, and two specific, constructive heuristics.

The so-called layout problem is a variant of the JSP arising in the apparel industry. The layout problem refers to a production process where first several layers of fabric are put on a cutting table, then a combination of several stencils are fixed on top of this stack, and eventually parts of clothing are cut of the fabric. The optimization problem is to find a set of stencil combinations and to determine for each combination the number of layers of fabric that are put together on the cutting table such that total setup cost and excess is minimized for a given demand. The layout problem compares to the planning problem discussed in the present paper as follows. The combinations of stencils correspond to the printing plates, the number of stencils that fit on the cutting table corresponds to the number of slots available on a printing plate, the different stencils correspond to the different designs, and the number of layers corresponds to the number of plate rotations. However, the layout problem does not include neither the white-border nor the color constraint; moreover, the number of layers per cutting operation is limited from above, and only a part of the cutting table may be used. Degraeve and Vandebroek (1998) formulate this layout problem as a mixed-integer linear program. Degraeve et al. (2002) propose two alternative mixed-integer linear models; the first model includes symmetry-breaking constraints, whereas the second model requires as input a set of all possible stencil combinations and uses binary variables to select a subset of these combinations. Martens (2004) develops two genetic algorithms for the layout problem based on a non-linear and a linear integer programming formulation. Rose and Shier (2007) address a variant of the layout problem in which the entire cutting table must be occupied by stencils except for the last stencil combination, and the demand must be satisfied exactly; the authors present an enumerative approach to minimize the total setup cost.

In the context of book-cover printing, the JSP is also called the cover-printing problem; here, the number of slots is four. Teghem et al. (1995) provide a non-linear and a linear programming formulation and a heuristic of the simulated-annealing type. Elaoud et al. (2007), Tuyttens and Vandaele (2010), and Romero and Alonso-Pecina (2012) propose a genetic algorithm, a greedy random adaptive search procedure and an ad-hoc heuristic, respectively. Peeters and Degraeve (2004) propose a branch-and-price algorithm for the co-printing problem, which is a variant of the cover printing problem. In this problem, the number of rotations is prescribed, not every slot must by occupied by an item, and the number of different item colors per plate is limited from above. Mohan et al. (2007) present a non-linear integer programming formulation and three specific constructive heuristics for an advertisement printing problem, which corresponds to a cover-printing problem with additional bounds on the number of rotations of each plate. Yiu et al. (2007) propose a two-level heuristic for the label-printing problem, which is another variant of the cover-printing problem in which empty slots are allowed, but penalized in the objective function.

4 MBLP model

In this section, we formulate the planning problem presented in Sect. 2 as a mixed-binary linear program. In Sect. 4.1, we formulate the objective function and the technological constraints. In Sect. 4.2, we introduce additional constraints for eliminating symmetric solutions from the search space.

We use the following notation.

$C=\{1,\ldots ,\mid C\mid \}$ :

Color codes

$I=\{1,\ldots ,\mid I\mid \}$ :

Designs

$I^O \subset I$ :

Customer-specific designs

$I^S \subset I$ :

Standard designs

$I_c \subseteq I$ :

Designs with color code $c$

$I_w \subseteq I$ :

Designs with white border

$J=\{1,\ldots ,\mid J\mid \}$ :

Slots

$P=\{1,\ldots ,\mid P\mid \}$ :

Plates

$\overline{c}$ :

Maximum number of different color codes per plate

$c_i^O$ :

Overproduction cost per unit of customer-specific design $i$

$c^P$ :

Setup costs per plate

$c^S$ :

Overproduction cost per unit of standard design

$d_i$ :

Demand of design $i$

$M$ :

Sufficiently large number

$u_{ijp}$ :

Units of design $i$ produced in slot $j$ of plate $p$

$v_i$ :

Overproduced units of design $i$

$W_p$ :

=1, if plate $p$ is used; =0, else

$X_{ijp}$ :

=1, if design $i$ is allocated to slot $j$ of plate $p$; =0, else

$Y_{ip}$ :

=1, if customer-specific design $i$ is allocated to plate $p$; =0, else

$Z_{cp}$ :

=1, if any design with color code $c$ is allocated to plate $p$; =0, else

Due to the split constraint, there is no feasible solution in which the number of plates used exceeds the number of customer-specific designs. Therefore, we define set $P$ such that $|P| = |I^O|$. W.l.o.g., we assume that $d_i>0$ for all $i\in I^O$. We choose the parameter $M$ to be $M=\max _{i\in I}d_i$.

4.1 Basic model formulation

The objective is to minimize the total cost for (a) overproduction of customer-specific designs, $\sum _{i \in I^O}c_i^Ov_i$; (b) overproduction of standard designs, $\sum _{i \in I^S}c^Sv_i$; and (c) setups, $\sum _{p \in P}c^PW_p$. Thus, the objective function is

$$\begin{aligned} \text {Min.} \sum _{i \in I^O}c_i^Ov_i+\sum _{i \in I^S}c^Sv_i+\sum _{p \in P}c^PW_p \end{aligned}$$

(1)

The number of overproduced units of a design is the difference between the number of units produced and the demand for this design, i.e.,

$$\begin{aligned} v_i = \sum _{j \in J; \, p \in P}u_{ijp} - d_i \quad (i \in I) \end{aligned}$$

(2)

where $d_i=0$ for standard designs $i\in I^S$. Because of $v_i\ge 0$ ($i\in I$), constraint (2) implies that the demand will be fulfilled.

If plate $p$ is used, then one design must be allocated to each slot of this plate, i.e.,

$$\begin{aligned} \sum _{i \in I} X_{ijp} = W_p \quad (j \in J; \, p \in P) \end{aligned}$$

(3)

If some units of design $i$ are produced in slot $j$ of plate $p$, then the design is allocated to this slot, i.e.,

$$\begin{aligned} u_{ijp} \le MX_{ijp} \quad (i \in I; \, j \in J; \, p \in P) \end{aligned}$$

(4)

The number of units produced in each slot of a plate must be the same for all slots, i.e., the number of rotations of the plate:

$$\begin{aligned} \sum _{i \in I}u_{ijp} = \sum _{i \in I}u_{i,j-1,p} \quad (j \in J: \, j>1; \, p \in P) \end{aligned}$$

(5)

To each plate $p$, designs with at most $\overline{c}$ different color-codes can be allocated, i.e.,

$$\begin{aligned} \sum _{c \in C}Z_{cp} \le \overline{c} \quad (p \in P) \end{aligned}$$

(6)

where $Z_{cp}=1$ if a design with color code $c$ is allocated to one or several slots of plate $p$:

$$\begin{aligned} \left| {J}\right| Z_{cp} \ge \sum _{i \in I_c; \, j \in J}X_{ijp} \quad (c \in C; \, p \in P) \end{aligned}$$

(7)

Moreover, for each plate, either a white-border design must be assigned to at least two slots or a standard design must be assigned to one slot, i.e.,

$$\begin{aligned} W_p \le \sum _{i \in I_w; \, j \in J}\frac{1}{2}X_{ijp} + \sum _{i \in I^S;j \in J} X_{ijp} \quad (p \in P) \end{aligned}$$

(8)

At most one standard design can be allocated to each plate, i.e.,

$$\begin{aligned} \sum _{i \in I^S; j \in J} X_{ijp} \le 1 \quad (p \in P) \end{aligned}$$

(9)

A customer-specific design must not be allocated to several plates, i.e.,

$$\begin{aligned} \sum _{p \in P}Y_{ip} = 1 \quad (i \in I^O) \end{aligned}$$

(10)

where $Y_{ip}=1$ if customer-specific design $i$ is allocated to some slots of plate $p$, i.e.,

$$\begin{aligned} \left| {J}\right| Y_{ip} \ge \sum _{j \in J} X_{ijp} \quad (i \in I^O; \, p \in P) \end{aligned}$$

(11)

In total, the basic optimization problem is

$$\begin{aligned} (\hbox{P})\left\{ \begin{array}{lll} \hbox{Min.} \quad & {(1)} & \\ \hbox{s.t.} \quad & (2){-}(11) & \\ & u_{ijp} \, \ge 0 &\, (i \in I; \, j\in J; \, p \in P) \\ & v_i \, \ge 0 & \, (i \in I) \\ & W_p \, \in \{0,1\} & \, (p \in P) \\ & X_{ijp} \,\in \{0,1\} & \, (i \in I; \, j\in J; \, p \in P) \\ & Y_{ip} \,\, \in \{0,1\} & \, (i \in I^O; \, p \in P) \\ & Z_{cp} \, \in \{0,1\} & \, (c \in C; \, p \in P) \\ \end{array}\right. \end{aligned}$$

4.2 Symmetry-breaking constraints

The set of feasible solutions to problem (P) contains many symmetric solutions, i.e., solutions that coincide with other solutions except that some slots or plates are interchanged. Jans (2009) demonstrates for the lot-sizing problem on parallel identical machines that the performance of the model improves considerably when symmetric solutions are removed by additional symmetry-breaking constraints. Recently, Jans and Desrosiers (2013) also applied symmetry-breaking constraints successfully to the so-called job grouping problem. In this subsection, we introduce additional constraints to eliminate such symmetries from the solution space w.l.o.g.

The designs allocated to the slots of a plate $p$ can always be sorted according to a non-decreasing design index, i.e.,

$$\begin{aligned} \sum _{i \in I}iX_{i,j-1,p} \le \sum _{i \in I}iX_{ijp} \quad (j \in J: j > 1; \, p \in P) \end{aligned}$$

(12)

Moreover, the plates with the smallest indices should be used, i.e.,

$$\begin{aligned} W_{p-1} \ge W_{p} \quad (p \in P: \, p>1) \end{aligned}$$

(13)

The plates can always be sorted according to a non-decreasing index of the design allocated to the first slot, i.e.,

$$\begin{aligned} \sum _{i \in I}iX_{i,j,p-1} \ge \sum _{i \in I}iX_{ijp} \quad (j=1; \, p \in P: p>1) \end{aligned}$$

(14)

In total, the optimization problem with symmetry-breaking constraints is

$$\begin{aligned} \hbox{(PS)}\left\{ \begin{array}{lll} \hbox{Min.} \quad & {(1)} \\ \hbox{s.t.} \quad & (2){-}(14) \\ & u_{ijp} \, \ge 0 & \, (i \in I; \, j\in J; \, p \in P) \\ & v_i \, \ge 0 & \, (i \in I) \\ & W_p \, \in \{0,1\} & \, (p \in P) \\ & X_{ijp} \, \in \{0,1\} & \, (i \in I; \, j\in J; \, p \in P) \\ & Y_{ip} \, \in \{0,1\} & \, (i \in I^O; \, p \in P) \\ & Z_{cp} \, \in \{0,1\} & \, (c \in C; \, p \in P) \\ \end{array}\right. \end{aligned}$$

5 Heuristic

In this section, we present a savings-based heuristic for the planning problem described in Sect. 2. The heuristic consists of a construction phase, in which an initial solution is computed, and an improvement phase, in which a simple local-search procedure is iteratively applied to the initial solution.

Roughly speaking, the construction phase proceeds as follows. First, we assign each design to an individual plate. Then, we iteratively merge plates such that the resulting solution is feasible, and the merger results in a reduction of the total cost. We analyze three alternative strategies to select the plates to be merged. The first strategy is to merge in each iteration one of the pairs of plates that results in the highest reduction of the total cost. The second strategy is similar to the first one, but we use a roulette-wheel procedure for selecting the pair of plates to be merged. The third strategy is to solve a matching problem in each iteration and to determine the pairs of plates to be merged from the solution to this matching problem; we formulate the matching problem such that some edge weights are influenced by random numbers. The solution obtained using the second and third strategies depends on the random numbers used; therefore, we propose implementing these strategies in a multi-pass procedure.

In Sect. 5.1, we describe the construction phase in more detail. In Sect. 5.2, we present the improvement phase.

5.1 Construction phase

In the construction phase, an initial feasible solution is computed as follows.

• (C1) Each design is allocated to a separate plate. If necessary, a standard design is allocated to satisfy the white-border constraint.

• (C2) For each pair of plates, the savings $S_{pp'}$ that result when merging plate $p$ and plate $p'$ are computed as follows.

  $$\begin{aligned} S_{pp'} \left\{ \begin{array}{l} = \text{Cost of plate } p + \text{ Cost of plate } p' - \text{Cost of merged plate}, \\ \quad\text{if merger is feasible} \\ = -\infty, \, \text{otherwise} \\ \end{array}\right. \end{aligned}$$

  A higher number of single-color plates tends to increase the number of possible mergers in later iterations. To favor mergers that result in single-color plates, we increase the cost of a plate by a penalty if more than one napkin color is allocated.

  The allocation of designs to slots of the merged plate is as follows. First, one slot is allocated to each customer-specific design. If necessary, a standard design is allocated to one slot to satisfy the white-border constraint. Second, for each design $i$, the minimum number of required rotations $r_i = \frac{{\text {Demand }d_i}}{\text {Number of occupied slots}}$ is computed. Third, the design with the highest value for $r_i$ receives an additional slot. These three steps are repeated until all slots are occupied. Then, $r_i$ is again updated and the number of rotations of the merged plate is set to the maximum value of $r_i$. Finally, the total cost of the merged plate, including the penalty cost, is computed.

• (C3) If no positive savings exist, then the construction phase terminates.

• (C4) Otherwise, one or multiple mergers are selected according to the specific selection strategy.

• (C5) The selected mergers are performed, and the savings for the resulting solution are computed ($\rightarrow$C2).

As mentioned above, we propose the following three alternative strategies to select the plates to be merged.

• 1. Greedy selection In each iteration, a merger with maximum savings is selected.

• 2. Roulette-wheel-based selection In each iteration, one merger with positive savings is selected using a roulette wheel. The probability $P_{pp'}$ that the merger of plates $p$ and $p'$ is selected is computed as follows:

  $$\begin{aligned} P_{pp'}= \frac{(S_{pp'}-\underline{S})^k}{\sum\limits _{p,p' \in P}(S_{pp'}-\underline{S})^k}, \end{aligned}$$

  where $\underline{S}$ denotes the minimum saving among all positive savings and $k$ is a parameter that controls the relation between the savings and the corresponding selection probabilities. With increasing $k$, the relative selection probability of large savings increases.

• 3. Matching-based selection In each iteration, a maximum-weighted matching problem is solved to select one or several mergers with positive savings. This problem involves selecting a subset of the edges of a graph such that no two edges are adjacent and the total weight of the selected edges is maximized. We construct the graph for this matching problem as follows. The plates of the current solution represent a subset of the nodes of the underlying graph. If the merger of two plates $p$ and $p'$ results in positive savings, an edge between the corresponding plate nodes $p$ and $p'$ with weight $S_{pp'}$ is introduced. Similar to the matching-based approaches for the vehicle routing problem (cf., e.g., Altinkemer and Gavish 1991), our heuristic performs advantageously when the number of different designs on the plates does not increase uniformly. To this end, we add a set of $n$ dummy nodes to the graph of the matching problem. We choose $n$ such that it is smaller than both, the number of positive savings and the number of plate nodes (see below). If a plate node is merged with a dummy node, then the corresponding plate will not be merged in the current iteration, i.e., the number of different designs on that plate remains constant.

  In order to increase the number of possible mergers in later iterations, we propose rather not to merge plates with few designs and white-border designs in early iterations. Every dummy node $d$ is connected to every plate node $p$ by an edge with weight $S_{dp}$. We chose this weight $S_{dp}$ as follows. Let $\overline{S}$ denote the maximum saving among all savings, $R^D$ and $R^W$ denote random integers in the interval [0,100), and $|J|$ denote the number of slots on a plate. Moreover, let $\sum _{i \in I^O}Y_{ip}$ denote the current number of customer-specific designs on plate $p$. We compute $S_{dp}$ by

  $$\begin{aligned} S_{dp} \left\{ \begin{array}{l} = \overline{S} + R^D(|J| - \sum \nolimits _{i \in I^O}Y_{ip}) + R^W, \, \text {if the plate associated with } p \\ \text {comprises a white-border design} \\ = \overline{S} + R^D(|J| - \sum \nolimits _{i \in I^O}Y_{ip}), \text {otherwise} \\ \end{array}\right. \end{aligned}$$

  The term $\overline{S}$ ensures that all dummy-nodes are merged in the optimal solution of the matching problem. The term $R^D(|J| - \sum _{i \in I^O}Y_{ip})$ increases with decreasing number of different designs on the plate. The term $R^W$ additionally increases the edge weight if the plate has a white-border design.

  Based on a non-negative user-defined parameter $D^R<1$, which we refer to as the dummy ratio, the number $n$ of dummy nodes is computed as follows:

  $$\begin{aligned} n = \left\lfloor {D^R\min (n_1,n_2)} \right\rfloor \end{aligned}$$

  where $n_1$ denotes the number of positive savings and $n_2$ denotes the number of plate nodes in the current matching problem. The dummy ratio $D^R$ is squared and the matching problem is solved again if no merger is performed despite the existence of positive savings.

  Figure 2 depicts the graph of the maximum-weighted matching problem for the illustrative example (cf. Sect. 2.2). The graph refers to the first iteration of the heuristic and was constructed using a dummy ratio of 0.5 and a penalty cost for different napkin colors of €200.

Fig. 2

Graph of the weighted-matching problem for the first iteration of the illustrative example

5.2 Improvement phase

After the construction phase, an iterative improvement procedure is applied to the initial schedule. This procedure is as follows.

• (I1) For each pair of customer-specific designs that are not allocated to the same plate, it is determined whether the total cost could be decreased by swapping the corresponding designs. The allocation of designs to slots is recomputed as described in step C2. Step I1 is repeated until no further cost reduction can be achieved; then, the improvement procedure continues with step I2.

• (I2) For each design, every feasible move to another plate is evaluated. The allocation of designs to slots is recomputed as described in step C2. If some cost reduction can be achieved, the improvement procedure continues with step I1. Otherwise, the procedure stops.

6 Results

In this section, we report the results of an experimental analysis of the mixed-binary linear model presented in Sect. 4 and the multi-pass matching-based heuristic presented in Sect. 5. In Sect. 6.1, we describe the set of problem instances used for the analysis. In Sect. 6.2, we report the results. First, we compare the results of the MBLP formulations with and without the symmetry-breaking constraints. Second, we compare the results of the heuristic under the three alternative selection strategies against the best result obtained using the MBLP formulations.

We implemented the MBLP models in AMLP and used the Gurobi Mixed-Integer Optimizer 5.6.2 as the solver. For the implementation of the multi-pass heuristic, we used ANSI-C; thereby, we used the Gurobi solver to obtain a solution of the matching problems. All computations were performed on a standard workstation with two Intel Xeon CPUs (model E5-2687W) with 3.10 GHz clock speed and 128 GB of RAM.

6.1 Test set and experimental design

We have generated the set of benchmark instances by varying the following problem characteristics.

• Number of designs N This parameter mainly drives the size of the MBLP model in terms of the number of decision variables and constraints. We have generated small-sized instances with 5, 10, and 15 different customer-specific designs, medium-sized instances with 20 and 25 different customer-specific designs, and large-sized instances with 30, 50, 70, and 90 different customer-specific designs.

• White-border ratio WR This parameter controls the number of designs with a white border relative to the total number of designs. We have generated instances with a low white-border ratio of 0.33 and with a high white-border ratio of 0.66. For each design, a random number between 0 and 1 is drawn. If this number is equal to or smaller than the white-border ratio, then the design belongs to the set of white-border designs.

• Color-code ratio CR This parameter is used to compute the maximum number of different napkin colors relative to the total number of designs. We have generated instances with a low color-code ratio of 0.15 and with a high color-code ratio of 0.3. For each instance, we first computed the maximum number of different napkin colors by rounding up the product of the corresponding values for $CR$ and $N$. Then, an integer random number between 1 and the computed maximum number of different napkin colors is drawn for each customer-specific design of this instance; this random number is the color code of the respective design.

• Demand ratio DR Similar to the color-code ratio, the demand ratio computes the maximum number of different demand values relative to the total number of designs. We have generated instances with a low demand ratio of 0.2 and a high demand ratio of 0.4. For each instance, we computed the maximum number of different demand values by rounding up the product of the corresponding values of $DR$ and $N$. Then, we divide the interval [5,000, 80,000] (which has been derived from the original data provided by the company) evenly into several intervals; the number of these intervals is defined by the computed maximum number of different demand values. Then, one of these intervals is chosen randomly; the demand value is then computed by rounding the center of this interval to the nearest multiple of 500.

We have generated one instance for each combination of the above-described parameters. In total, the test set comprises 40 small- and medium-sized instances and 32 large-sized instances. In all instances, the overproduction cost are €0.0035 per unit of customer-specific design and €0.001 per unit of standard design. The setup cost per plate are €540.

We applied the MBLP model with and without symmetry-breaking constraints to all of the 72 instances. Thereby, we set a CPU time limit of 1,800 seconds per instance for the Gurobi Optimizer. For the heuristic approaches, we have used a penalty cost for the allocation of different napkin colors of €200. We applied both the heuristic with the roulette-wheel-based and the heuristic with the matching-based selection strategy 50 times to each instance.

For the roulette-wheel-based selection strategy, we used the value $k=3$ for the computation of the relative selection probabilities. We tested the values $k=0,1,\ldots ,15,20,\ldots ,95,100$; Table 2 indicates for each value of $k$, the number of instances for which the best objective function value among these values for $k$ was obtained. The best results were obtained for $k=3$ and for $k=6$.

Table 2 Number of best solutions (best) obtained for different values of parameter $k$ within the roulette-wheel-based heuristic

For the matching-based selection strategy, we set the dummy ratio to $D^R=0.5$ and prescribed a CPU time limit of 5 s per iteration for the Gurobi Optimizer.

6.2 Numerical results

The numerical results of our analysis for the MBLP formulations and the heuristic with the different selection strategies are reported in Tables 3, 4, 5 and 6, respectively. In the first part of this subsection, we are concerned about the results obtained with the MBLP formulations; in the second part of this subsection, we discuss the results obtained with the heuristic approach.

The second to the fifth column of Table 3 refer to the characteristics that were varied to generate each small- and medium-sized instance. In columns 6–11 of Table 3, we present for each instance and the MBLP model without symmetry-breaking constraints, i.e., model (P), and the MBLP model with symmetry-breaking constraints, i.e., model (PS), the objective function value (OF), the MIP gap (G) and the required CPU time (T). For each instance, the best objective function value found is marked in bold face. The entry lim means that the solver was stopped because the prescribed time limit had been reached; the entry na indicates that no feasible solution was found within the prescribed time limit.

For small-sized instances, model (PS) considerably outperforms model (P). Model (PS) solves all of the 24 small-sized instances to optimality, whereas model (P) solves only 12 instances to optimality within the prescribed time limit. For all medium-sized instances, however, the solutions found by model (P) have the same or a better objective function value than the solutions found by model (PS). However, for instances with up to $N=20$ customer-specific designs, the MIP gaps obtained with model (PS) are smaller than the gaps obtained with model (P); in particular for $N=20$, the lower bounds provided by model (PS) are considerably higher than for model (P).

In Table 4, we report analogously the results of both MBLP models for the 32 large-sized instances. Model (P) finds feasible solutions for 23 of all large-sized instances, whereas model (PS) can only devise feasible solutions for two large-sized instances. Hence, the symmetry-breaking constraints seem to exclude large areas of the search space, such that finding a feasible solution gets more difficult. From the results for model (P), we conclude that a high color-code ratio seems to render the problem instance more difficult.

As model (PS) often has difficulties to find a feasible solution within the prescribed time limit, we analyzed the usefulness of providing an initial feasible solution to model (PS), which we generated using the heuristic under the greedy selection strategy (cf. also Tables 5, 6). In the last three columns of Tables 3 and 4, we list the respective objective function values, the gaps, and the required CPU time. Instances for which the MILP solver found a better solution than the provided initial solution are marked with asterisk. For the small- and medium-sized instances, the initial solution could be improved for 19 instances. By providing an initial solution, the MIP gaps of model (PS) could be reduced for 9 instances. However, for 7 instances larger MIP gaps were obtained. For the large-sized instances, only one initial solution could be improved. The impact on the MIP gaps of model (PS) for large-sized instances cannot be evaluated properly as there is only one instance for which model (PS) found a feasible solution. Overall, providing an initial solution does not increase the performance of model (PS) substantially.

Table 3 Numerical results of the MBLP-models (P) and (PS) for small- and medium-sized instances

Table 4 Numerical results of the MBLP-models (P) and (PS) for large-sized instances

Next, we turn to the heuristic approach. In Tables 5 and 6, we present the results of the heuristic under the three alternative selection strategies for the small- and medium-sized, and the large-sized instances, respectively. For each selection strategy and each instance, we report the objective function value that was obtained after the construction (column OF$^\text {C}$) and after the improvement phase (column OF$^\text {I}$), respectively. For the multi-pass implementations, we applied the improvement phase after each pass and report the best solution found within the 50 passes after the construction and after the improvement phase. For each instance we set the best objective function value(s) in bold face. In addition, we report for each strategy the total CPU time required T, and the relative deviation D to the best solution found by the MBLP models. The CPU time reported for the multi-pass implementations includes all 50 passes.

Both the roulette-wheel based and the matching-based selection strategy outperform the greedy selection strategy for the small- and medium-sized instances (cf. Table 5). Both approaches devise for 23 of the 24 small-sized instances an optimal solution within short CPU times. The cost reduction achieved by the improvement phase tends to increase in the number of designs. From Table 6, we conclude that for the large-sized instances, all solutions found by the matching-based strategy have smaller objective function values than the best solutions found by either MBLP formulation. The relative advantage of the matching-based selection strategy tends to increase in the number of designs. Furthermore, for large-sized instances, the roulette-wheel based selection strategy is generally outperformed by the greedy selection strategy. One reason for that may be that the large portion of the roulette wheel which represents mergers that result in moderate or low savings deteriorates the performance of this selection strategy.

To evaluate the robustness of the multi-pass implementations, we report in Tables 7 and 8 the minimum, the average, and the maximum objective function value after the improvement phase. In columns five and nine of these two tables, we state the relative gap between the minimum and the maximum objective function value for each instance. The results indicate that the matching-based selection strategy is more robust, especially for large-sized instances.

Table 5 Numerical results of the heuristic approaches for small- and medium-sized instances

Table 6 Numerical results of the heuristic approaches for large-sized instances

Table 7 Robustness of multi-pass heuristics for small- and medium-sized instances

Table 8 Robustness of multi-pass heuristics for large-sized instances

7 Conclusions

Within the context of a real-world offset printing process for manufacturing napkin pouches, we have analyzed the problem of determining a number of printing plates, a feasible allocation of designs to the slots of these plates, and a number of rotations of each plate such that a given customer demand is fulfilled for all designs and the total overproduction and setup costs are minimized. First, we have formulated this problem as a mixed-binary linear program, which we have then extended by additional constraints to remove symmetric solutions from the search space. Second, we have developed a heuristic solution approach, which consists of a construction phase and an improvement phase; the construction phase is related to matching-based savings heuristics for the vehicle routing problem. Our computational results indicate that within reasonable CPU times, optimal solutions to small-sized instances can be determined using the MBLP model with symmetry-breaking constraints. For medium- and large-sized instances, the model without symmetry-breaking constraints performs better; however, no feasible solution is found for approximately half of the large-sized instances, and rather large MIP gaps are observed. Using the multi-pass savings-based heuristic, we could devise optimal solutions for all small-sized instances; for medium and large-sized instances, the heuristic outperforms the MBLP model considerably.

The real business world situation discussed and the solution approaches proposed in this paper open up an interesting area for the application of combinatorial optimization in production planning and control. An important area of future research is the development of hybrid solution approaches, i.e., to combine the MBLP model formulation presented in this paper with an heuristic search strategy. In addition, alternative mixed-integer linear programming formulations should be investigated; one possible direction would be to generate a set of promising plate patterns, and to use linear programming for selecting a feasible subset of these plate patterns with minimal total cost.