Abstract
The NP-hard cover printing problem addressed here consists in determining the number and composition of equal size impression grids, as well as the number of times each grid is printed, in order to fulfill the demand of different book covers at minimum total printing cost. The considered costs come from printing sheets and for composing grids. Thus, to deal with this combinatorial optimization problem we investigated two heuristics: one combines simulated annealing and linear programming techniques and the other is a hybrid of Tabu Search and an ad hoc procedure. Through intensive testing on available instances, these algorithms proved to be superior to previous approaches.
1. Introduction
This paper deals with a scheduling problem motivated by the printing industry. We will refer to it as the cover printing problem, although including its variants is also known as the job splitting [1], the label printing [2, 3], and the advertisement printing [4] problem.
Central to the process of producing types of equal size book covers is to print an impression grid (or press, template, master, etc.) composed of a set of equal size plates, where some of them may be identical. To fulfill a given demand of book covers interrelated decisions must be made on the number and composition of impression grids (grids, for short) and on the amount of imprints made with each. One imprint of a grid produces one large printed sheet of paper which, once cut into parts, yields cover copies.
Two constants are relevant to the decision process: the cost for printing one sheet and the cost for composing one grid . Thus, the cover printing problem (CPP) consists in determining —at minimum total cost—the number and composition of grids, and the number of imprints made with each, so as to fulfill the required demand for each type of cover.
A Toy Example. Let be the number of covers, the grid size, and the required demand vector, for a total of 200 copies. A feasible solution of the CPP is found by composing grids as described by the ()-matrix of (1) (matrices to be discussed later), where is the number of plates of cover in grid , and , for . Then, if grids 1, 2, 3, are printed 29, 16, and 22 times, respectively, the covers’ demand is satisfied. Observe that imprints are made, producing copies, with wasted, namely, 34% of wastage. Further, is the total cost of this solution, whose optimality clearly depends on the relative values of and .
The computational complexity of the CPP is not known to date. However, some special cases have been polynomially solved by Ekici et al. [1] and Romero & Alonso-Pecina [5]. On the other hand, the CPP is strongly NP-hard when [1]. Besides a handful of graduate thesis (namely, four Belgian graduate thesis cited in [6–8], not available to the authors, and the Latin American graduate thesis by Calderón [9] and Carrera [10]) few internationally published papers have studied heuristic approaches for this highly combinatorial problem and its variants. These approaches are assorted, going from simulated annealing (Teghem et al. [7], Yiu et al. [3]) to GRASP (Tuyttens & Vandaele [8, 11]), as well as from evolutionary algorithms (Elaoud et al. [6], Hsieh et al. [2]) to ad hoc heuristics (Ekici et al. [1], Mohan et al. [4], and Romero & Alonso-Pecina [5]).
Several CPP variants have been investigated. Romero & Alonso-Pecina [5] proposed to add a Hamiltonian path procedure to their ad hoc heuristic when there is also a cost for each produced plate. Other variants consist in the inclusion of additional constraints: while Mohan et al. [4] tackle the case of lower and upper bounds on the number of imprints made with each grid, Yiu et al. [3] and Mohan et al. [4] assume the number of grids as prescribed. Finally, Yiu et al. [3], Hsieh et al. [2], and Tuyttens & Vandaele [11] consider the constraint that all copies of any cover should be produced by one single grid.
The aim of this paper is to propose two new heuristics to successfully approach the solution of the CPP. One, hybridized with linear programming, has the simulated annealing technique as motif; the other strategically combines Tabu Search and ad hoc procedures. We are witnessing a recent, interesting trend about the hybridization of metaheuristics and other techniques for optimization, like local search or exact algorithms (see the excellent survey by Blum et al. [12], as well as Gomes & Oliveira [13], Caserta & Voss [14], Popović et al. [15], López-Ibáñez et al. [16], and Mestria [17], among others). Such types of hybridization are intended to take advantage of strengths from each algorithm to improve the algorithms’ performance when solving different combinatorial optimization problems.
This paper is organized as follows. Section 2 provides an integer programming formulation of the CPP. Then, our simulated annealing programming and Tabu Search/ad hoc heuristics are described in Sections 3 and 4, respectively. Computationally tested on the 88 instances available in the specialized literature, our heuristics, taken together, improved the known best solution of more than two-thirds of them; this is discussed in Section 5. Finally, Section 6 contains our conclusions.
2. Integer Programming Formulation
The following mathematical formulation of the cover printing problem improves on the one proposed by us in [5]. Let , and , , and be the set of covers, the requirements vector, the grid size, the cost for printing one sheet, and the cost for composing one grid, respectively. Without loss of generality assume . Letting be the set of possible impression grids, where can be computed as , consider the -by- matrix where is the number of plates of cover in grid . Obviously each column sums up to .
Thus, the CPP can be posed as one problem of integer programming:where and are the decision variables, with if and only if grid is selected and being the number of its imprints. Problem is intractable since the number of possible grids is exponential. For the toy example of Section 1 we have , yielding 140 integer variables and constraints.
Let be an -by- submatrix of , whose columns have been reindexed, , and consider the integer programming problem
Obviously, any feasible solution of can be extended to an also feasible solution of problem by making for all columns not belonging to , and for . In the sequel we assume this extension is implicitly made.
It has been remarked [1, 5] that no feasible solution to the CPP exists with less than grids, and there is no optimal solution to the CPP with more than grids. Hence, define as the set of -by- submatrices of without zero rows, with satisfying .
Now, for , denote by the optimal solution of problem , and denote by the rounded up, optimal solution of problem when solved without integrality constraints (7). From the previous paragraph not only the pair is a feasible solution to the CPP, but there exists such that is an optimal solution to the CPP.
In view of the high demand values normally found in the internationally published instances (most demand values are between and [6–8]), in our approach we opted to only deal with the CPP solutions of type , considering its inherent error immaterial.
3. Simulated Annealing/Linear Programming Approach
In this section we present the first of the two heuristic approaches we propose for the solution of the cover printing problem. This heuristic—we call it SALP—is centered in the simulated annealing concept hybridized with linear programming techniques. A recent, good overview of simulated annealing can be found in [18], and for linear programming we refer the reader to [19]. SALP is similar in essence to the Teghem et al. proposal [7]; however, arising from the final remarks of Section 2, it differs in regard to the neighborhood definition. Namely, for a given matrix , the neighborhood of solution is the set containing every solution such that is obtainable from by either(i)adding 1 to and subtracting 1 from , for some indexes , or(ii)adding 1 to and and subtracting 1 from and , for some indexes .
Thus, SALP consists in performing the procedure ANNEAL followed by the procedure REFINEMENT, the former drawing upon procedures LINPROG, RAND, INITIALSOL, RESIZE, and NEIGHBOR. Each is described below. We thoroughly assume all random numbers are generated with uniform probability distribution.
LINPROG. Given an -by- matrix , this procedure consists of a standard implementation of the Simplex method for linear programming. It is aimed at finding as defined in Section 2, namely, the rounded up optimum of the linear programming relaxation of problem . Hence, the solution is delivered, as well as its cost , where stands for the number of positive entries in . Recall that and are the unit costs for sheet printing and grid composing, respectively. Although the Simplex method has computational complexity , its general good behavior is a well known fact: the observed average of iterations is roughly .
INITIALSOL. An initial, feasible solution to CPP is built in two steps. First, an -by- matrix is constructed, where is randomly generated in the set , for , ensuring that has no zero rows, and each of its columns sums up to . It proceeds as follows: Lines (1) to (10) build an integer, nonnegative matrix with no zero rows, whose column sums are equal or less; then lines (11) to (20) ensure that each column sums up to . To end, procedure LINPROG is called to determine , completing the construction of the initial solution , and its cost .
The overall complexity of this procedure is , namely, the same as that for LINPROG (Algorithm 1).
| ||||||||||||||||||||||||||||||||||||||||||
RAND. This function delivers a random real number in the interval (0, 1).
NEIGHBOR. Using the neighborhood as defined in the first paragraph of this section, this procedure—of computational complexity —randomly produces a feasible solution in .
RESIZE. This procedure takes a solution as input and produces a solution as follows. First and let be the number of zeros in . If then delete the first columns such that . Otherwise, if and has less than columns then a nonnegative integer column is added to it, where(i),(ii), for all , and(iii) implies , for all .
To end, procedure LINPROG is called to determine and cost , where . The computational complexity of this procedure is clearly . The rationale for this procedure is to allow the number of grills in the solutions found during the search to increase.
ANNEAL. This procedure basically consists of standard simulated annealing iterations where parameters , denote, resp., the cooling factor, the internal cycle length, the initial temperature, and the final temperature (Algorithm 2).
| ||||||||||||||||||||||||||||||||||||||||||||
The complexity of the algorithm is given by the number of times the two cycles are performed times the complexity of LINPROG. While the first cycle is performed until reaches , say, times, where [20], the inner cycle is performed times, and LINPROG has complexity . So, the total time is .
Above, we have pointed out that our procedure SALP is similar in essence to that of Teghem et al. [7]. Besides the fact that we use a different and larger neighborhood, the main difference between both approaches is that, along the search, in ours the number of grids equals the number of nonzero variables in the optimal solutions given by linear programming (LP), while in theirs it is just the opposite: the number of grids is determined by an element of the neighborhood employed in simulated annealing (SA). We mention that [7] is one of the pioneering papers on the CPP. Among the small instances I001–I004 considered therein, the authors found the optimal solution of two of them; while in our present approach as well as in those in [5, 8, 11] the four instances were solved to optimality.
REFINEMENT. A local search procedure (LS) attempts to deterministically improve a given solution . LS considers all the elements of one at a time; if none improves on cost , the procedure stops; otherwise is replaced by the first found solution of with lower cost than , and LS starts anew. The complexity of LS is that of entirely exploring the neighborhood multiplied by , namely, .
Now, let us return to the toy example of Section 1 and consider the matrices , , and , in (1). Also, let and , and assume INITIALSOL generates , where is obtained by LINPROG. This is to say, solution consists of three grids (columns 1, 2, and 5 of ), imprinted 11, 36, and 7 times, respectively, yielding .
Taking as input, the procedure RESIZE produces , , and . Then, from and after a few iterations, SALP successively obtains , , , and , which turns out to be the global optimum of the toy example.
4. Tabu Search/ Approach
Our second approach consists of the hybridization of two heuristics: the Tabu Search technique (TS) and an ad hoc procedure called here , whose aim is to provide an initial solution to TS.
A thorough description of the heuristic can be found in [5]; however, we find it convenient to sketch here its main idea: at each of the outer iterations a solution is sought that minimizes the number of required grids subject to the constraint that for any cover the wastage is lower or equal to a given upper bound. This upper bound is initialized with the maximum demand and is monotonically decreased in each outer iteration as long as new solutions are found or until it reaches zero. In the end, the solution with the minimum cost among those produced in the outer iterations is retained.
Successfully used to tackle combinatorial optimization problems galore (see, for example, [21] and the references therein), Tabu Search [22] is based on a tabu list of forbidden movements that is updated during the iterations to avoid cycling and get stuck in local minima. Our approach TS/ considered an enlargement of the neighborhood —defined in Section 3—so as to include the feasible solutions that can be obtained by deleting any one grid; we denote by this neighborhood. In the pseudocode TS/ below the procedures NEIGH and NOTTABUNEIGH produce the best feasible solution, respectively, in and in (Algorithm 3).
| ||||||||||||||||||||||||||||||||||||||||
In line (1) a solution is heuristically produced by procedure , which is hereupon used as initial solution by the Tabu Search algorithm. In lines (2–4) several variables are initialized, among them is a nonnegative integer -by- matrix to represent the tabu list (here, denotes the zero matrix). The main cycle (5–19) is performed a maximum of times without improving the best solution found. In our experiments we set . The procedure NEIGH (line 6) obtains a solution (using first-best strategy) in the neighborhood improving the best solution found so far (if such solution exists). The solution is evaluated in lines (8–11); then, if improves on the so far best solution found, the latter is updated and the integer count is reset (lines 9–11); otherwise (lines 13–17) the best solution without tabu status is chosen as .
In line 15 the function UPDATE() makes RAND for each entry of that has been modified (recall that is part of the solution , as defined in Section 3). Thus, the entry of matrix cannot be changed as long as ; namely, it gets tabu status for a number of iterations randomly chosen in the range .
The complexity of procedure TS/ is the complexity of plus the TS complexity. From computational experimentation we found that, in general, is a reasonable upper bound for the number of times the main cycle of TS is performed. As is a constant, the complexity of Tabu Search comes to that of LS: . As this dominates that of , [5], the overall complexity of TS/ is .
5. Numerical Results
The procedures described in Sections 3 and 4 were implemented on a computer with Xeon 3.5 GHz processor, 64 GB RAM, and g++ compiler in an Ubuntu Operating System. They were tested on all instances proposed in [8], available in www.matcuer.unam.mx/~davidr/cpp.html. Also, to find the global optimum of some instances we used the exact algorithm described in [5].
As for the SALP parameters we selected and , because from our computational experiments they yielded, respectively, an average of accepted solutions close to 99%, and an average of accepted solutions of around 2.5%. Also, we experimentally found that in terms of solution quality and computational effort a desirable combination of cooling factor and cycle length was, respectively, and . Each considered instance was solved 100 times.
Tables 1 and 2 show the achievements of our procedures for instances – and –, compared with the best found in the literature. Global optima are marked with an asterisk (). The Appendix provides a detailed description of our solutions for –. In Table 1, column indicates the number of times the best solution was obtained by SA/LP. In the case of instance I016, one hundred runs were made, the lower and the higher costs found being and , respectively. Each run took seconds on average.
To test several heuristics, a set of 15 instances, see [5, 8, 11], all with , has been used in combination with grid costs: (), yielding a total of 75 cases. Table 3 displays our results on this set, comparing them with the best found so far, namely, those obtained with GRASP [11] (excepting instance 50-4 with grid cost ). The first portion of the instance name corresponds to the number of covers. For each of the 75 cases the best results are shown in bold face. An asterisk () marks global optima (when able to compute them). The number of times SA/LP obtains the best solution is 17 for instance (30-1,), nine for instance (30-4,), five for instance (30-3,), two for instances (30-2,), (30-5,), (40-1,), (40-2,), (40-3,), and (30-3,), and once for the remaining 66 instances. On average, linear programming took 97.65% of the total time of each run.
We observe the dominance of SA/LP for instances 30-x when the grid cost is in the range [,], for instances 40-x when this cost is in the range [,] and for instances 50-x when the cost is . Also, SA/LP seems the best choice when the grid cost is relatively high or the number of covers is low. In total, SA/LP finds the best result in 45 of the 75 instances (including ties).
As of heuristic /TS, it finds the best result for instance 30-4 when the cost is or , for instances 40-2, 40-3, and 40-4 when the cost is , for instance 40-4 when the cost is , and for instances 50-x when the cost is in the range [,], with one case excepted. Thus, /TS seems the best when the number of covers is high and the grid cost is small. All in all, /TS finds the best result in 24 of the 75 instances (ties included).
For its part, GRASP dominates in instances 30-x with cost , in instances 40-x with cost in the range [,], and in instances 50-x with several combinations of instance-cost; it obtains the best result four times. GRASP seems to be the best option when the grid cost is small and the number of covers is below 40. Altogether, GRASP finds the best results in 20 of the 75 instances (ties included).
In regard to computational effort it is difficult to assess our proposal, and not only because GRASP was run on a computer different from ours. In the GRASP implementation, the number of grids is fixed, so the reported average execution times correspond to a given number of grids. Conversely, in SA/LP and /TS the number of grids is a variable to be determined. In our experiments /TS was run only once for each instance, because its behavior is nearly deterministic, the sole random component being the amount of time each element stays in the tabu list.
Table 4 shows the computer time needed by our two heuristics for instances 30-x, 40-x, and 50-x. The figures for SA/LP correspond to average times (in seconds) of one run. Clearly, none of the procedures has linear complexity; this largely explains the observed increase in time as grows.
We also tested SA/LP and /TS on 60 instances found in www.matcuer.unam.mx/~davidr/cpp.html, whose optimum is known. Table 5 shows the obtained results, where it can be seen that SA/LP gets indeed the optimum for the first 30 instances, and it outperforms /TS for instances . However, /TS obtains the best solutions for .
It is worth mentioning that a similar behavior can be observed for instances in Table 3, where /TS tends to dominate as grows and decreases.
6. Conclusions
In this paper we have presented two competitive procedures for the cover printing problem, SA/LP and /TS, comparing their results with the best found for a selected set of 88 instances from the specialized literature. Our computer experiments show that our heuristics, taken together, although not dominating in all of these instances, allowed improving the known best solution of 68% of them, their success depending more on the characteristics of the problem treated.
A total of 60 better results were obtained in the chosen set: five in the group of 13 instances of type xxx and 55 in the large group of 75 instances.
It is worth mentioning that one of the advantages of our heuristics is that none of them requires presetting the number of grids.
For future work it is desirable to intensify the study of new, original approaches to this difficult combinatorial optimization problem, so as to better understand its intricacies and provide improved solutions.
Appendix
Tables 6, 7, 8, 9, and 10 contain a detailed description of our solution to instances , , , and , as well as the worst solutions obtained in one hundred runs for instances 30-x, 40-x, and 50-x. All results were found with SA/LP.
Data Availability
We are willing to give all the instances and our solutions to the persons who request them.
Conflicts of Interest
The authors declare that there are no conflicts of interest regarding the publication of this article.