Pattern-based diving heuristics for a two-dimensional guillotine cutting-stock problem with leftovers

Abstract

In the two-dimensional guillotine cutting-stock problem, the objective is to minimize the number of large plates used to cut a list of small rectangles. We consider a variant of this problem, which arises in glass industry when different bills of order (or batches) are considered consecutively. For practical organization reasons, leftovers are not reused, except the large one obtained in the last cutting pattern of a batch, which can be reused for the next batch. The problem can be decomposed into an independent problem for each batch. In this paper, we focus on the one-batch problem, the objective of which is to minimize the total width of the cutting patterns used. We propose a diving heuristic based on column generation, in which the pricing problem is solved using dynamic programming (DP). This DP generates so-called non-proper columns, i.e. cutting patterns that cannot participate in a feasible integer solution of the problem. We show how to adapt the standard diving heuristic to this “non-proper” case while keeping its effectiveness. We also introduce the partial enumeration technique, which is designed to reduce the number of non-proper patterns in the solution space of the dynamic program. This technique strengthens the lower bounds obtained by column generation and improves the quality of the solutions found by the diving heuristic. Computational results are reported and compared on classical benchmarks from the literature as well as on new instances inspired from glass industry data. According to these results, variants of the proposed diving heuristic outperform constructive and evolutionary heuristics.

Appendix

In the appendix, we report results for the standard bin minimization objective function, i.e. for the case when keeping leftovers for the next batch is not permitted. Once the last bin in a sequence of patterns is cut and items are obtained, the remaining glass part is considered as a waste and not reused. Clearly, this is not efficient in terms of the glass waste reduction. However, this case is much more easier to manage in practice. Results are valid for the same set of cutting constraints described previously for the 2DGCSPL.

Results reported in Table 6 show the impact of partial enumeration when solving the linear relaxation of the problem with column generation. The first column reports the instance class and its total number of instances between brackets. The second $\#ps$ shows the number of instances solved in preprocessing. The next three columns present results for the variant $cg_{mip}$: number of instances for which the column generation converged within one hour, average time (t) in seconds, and the average primal-dual gap (gap) in percentage from the best known solution. Next three columns give the average gap ($gap_{\#opt}$) for other three variants of column generation. In order to have a correct comparison, averages in columns $gap_{\#opt}$ are calculated only for instances for which the variant $cg_{mip}$ converged. Note that, the column generation variants with dynamic programming converged within the time limit for all instances. Thus, in columns $gap_{all}$ and $t_{all}$, we give the average gap and the average solution time among all instances for all hypergraph configurations. Note that average value are computed on instances not solved in preprocessing.

Table 6 Comparison of different column generation variants with the bin minimization objective function

From experiments reported in Table 6, it can be seen that the impact of partial enumeration in the case of the classic objective function is much smaller than in the case of leftovers. For the industrial instances, the impact is negligible.

Results for direct solution by CPLEX MIP solver are reported in Table 7. The column $(\#ps)$ shows the number of instances solved by preprocessing. In columns ($\#opt$), we report for each variant of the formulation the number of instances solved in one hour ($\#opt$), excluding instances solved by preprocessing. In columns (t), we give the average solution time (t) in seconds, computed over all instances including those solved by preprocessing. If a timeout is reached for an instance, we use the time limit value in the calculation of the average time.

Table 7 Comparison of variants of the hypergraph-based MIP formulation with the bin minimization objective function

Results show that instances with the bin minimization objective are much easier than instances with the leftover maximization objective. Here again, the impact of the partial enumeration is very small.

In Table 8, for each considered heuristic, we show the average gap in percentage from the best known solution and the average time in seconds. Reported average values are computed on the whole set of instances in each dataset even if an instance is solved in preprocessing. The results for heuristics (ediv) and $(ediv_{32})$ are not shown as they are similar to results of (div) and $(div_{32})$.

Table 8 Comparison of heuristics with the bin minimization objective function

From Table 8, one can see that the performance of diving algorithms with LDS is comparable to one of heuristic (iub). However, the running time of the former is smaller. Again, the comparison of results for heuristics $(div_{\emptyset })$ and (div) allows us to conclude that the partial enumeration not only improves but worsens the results. The results for industrial instances show that no heuristic manages to improve the performance of the simplest heuristic (ea). This can be explained by the fact that the objective function is “flat”, and it is very hard to improve the obtained solution even by 1 unit.

In Table 9, we report the results obtained by the same heuristics tested before for the case with multiple batches. For each heuristic, we show the solution value obtained, which is equal to the average number of plates needed to cut items from all batches, as well as the average solution time in minutes. We also give the average lower bound (lb) on the optimal value. For each instance, this value is obtained by iteratively computing the rounded-up column generation lower bound for each batch and determining the number of bins to use.

Table 9 Comparison of heuristics on the real-world instances with batches and the bin minimization objective function

From these results, it seems that the simplest heuristic (ea) is the best one in terms of the “quality/running time” trade-off. Using more complex heuristics, one cannot improve significantly the results. However, as it was shown in the paper, one can improve largely the results by allowing one to reuse the leftovers in the next batch. In the case with leftovers, advances heuristics are useful to reduce the waste of glass.