Optimally rescheduling jobs with a Last-In-First-Out buffer

This paper considers single-machine scheduling problems in which a given solution, i.e., an ordered set of jobs, has to be improved as much as possible by re-sequencing the jobs. The need for rescheduling may arise in different contexts, e.g., due to changes in the job data or because of the local objective in a stage of a supply chain that is not aligned with the given sequence. A common production setting entails the movement of jobs (or parts) on a conveyor. This is reflected in our model by facilitating the re-sequencing of jobs via a buffer of limited capacity accessible by a LIFO policy. We consider the classical objective functions of total weighted completion time, maximum lateness and (weighted) number of late jobs and study their complexity. For three of these problems, we present strictly polynomial-time dynamic programming algorithms, while for the case of minimizing the weighted number of late jobs NP-hardness is proven and a pseudo-polynomial algorithm is given.

In several industrial settings, different unforeseen phenomena, such as data-obsolescence or disruptions, could deteriorate the performance (or optimality) of the planned ahead schedule. In this case, it is sometimes possible-or even necessary-to compute a new schedule by rearranging the previous job sequence. A similar situation frequently occurs, e.g., in lot production or in operating-rooms scheduling. In the first case, lots must typically go through several working stages: Between two of them, it may be beneficial to reorganize the sequence, owing to, for instance, different characteristics of the lots in the next stage. In the second case, a tentative schedule for a certain planning period is built in advance and, later on, the final schedule is output trying to minimize changes with respect to the original plan.
In this context, we are interested in the following problem: We are provided with an initial job sequence to feed a single processing resource; we need to rearrange the jobs such that the new sequence performs well in terms of some given criterion. Depending on the considered setting, we also need to deal with a given set of feasible reconfigurations (such restrictions may be imposed, e.g., by the physical handling system of the plant) which are, somehow, not too distant from the original sequence. A special version of this problem is also considered in Alfieri et al. (2018a, b). The authors studied a rescheduling problem with the constraint that the jobs extracted from the given initial sequence can be re-inserted only in later positions, i.e., jobs can be postponed but not moved ahead of the schedule. This corresponds to a physical setting where jobs are transported on a conveyor that feeds a single processor and a robot or worker can pick them up and reinsert them later in the queue.
In this paper, we adopt a similar setting but with an additional set of restrictions. In particular, we consider the scenario in which the handling mechanism consists of a conveyor that feeds a single machine in a given sequence and a robot, placed along the line, that is able to alter this sequence. The robot may pick parts from the conveyor as they are moving, stacks them on a buffer of finite capacity from which it takes the parts and places them back on the conveyor, in their final positions (which is later in the original sequence due to the conveyor movement). Since the stack is managed according to a Last-In-First-Out (LIFO) policy, only the last part put into the stack can be extracted and re-inserted in the new sequence. This setting has been introduced in Nicosia et al. (2019) where the authors present some preliminary results on the corresponding rescheduling problem.
An area of research which is strictly related to the problem we address in this article, deals with sequence coordination in supply chain (SC). One of the main tasks in SC management is indeed coordination of several activities performed at different stages of the chain. An obvious overall goal consists in successfully meeting customers needs and achieving a good level of efficiency and performance. Usually, in a coordinated SC, two or more processes subject to their mutual coordination are considered. This involves fitting the schedules of different manufacturers together when some planned or unexpected schedule changes are experienced by one or more of them (Ivanov and Sokolov 2015). In this context, Agnetis et al. (2006) consider two consecutive stages of a supply chain where ideal job sequences (typically, different for the two stages) are given. The authors address a supply chain scheduling coordination problem consisting in finding a trade-off schedule that takes into account the ideal schedules of both stages. They propose a number of polynomial-time algorithms for different versions of the problem, namely from the point of view of the manufacturer, then from that of the supplier, and, finally, they consider the situation when both stages cooperate to obtain a satisfactory compromise schedule. A related coordination problem is addressed in Agnetis et al. (2001) where two departments in a manufacturing facility process the jobs in batches. In a first department, a setup is paid whenever a certain attribute changes from one batch to another, whereas in a second department, the setup is associated to a different attribute. The problem of finding a unique sequence of jobs in order to minimize the overall setup cost arises. The authors prove that the problem is NP-hard and propose an effective heuristic approach. The above coordination problems are also tightly connected to those addressed in multi-agent scheduling, a research field which received great attention more recently: Two or more agents have to agree on a fair, i.e., acceptable schedule of their distinct sets of jobs on a common processing resource [see, for instance, Leung et al. (2010), Perez-Gonzalez and Framinan (2014) and Agnetis et al. (2019)].
Another important and fruitful research stream, connected to the problem addressed here, concerns the so-called rescheduling (or dynamic scheduling). In many real-world scenarios, scheduling is an activity requiring frequent revisions due to unexpected changes such as, for instance, machine breakdown or unavailability, delay in the arrival of materials, job cancellation, due date changes, etc. With the terms rescheduling and dynamic scheduling, many authors indicate the problem of scheduling in the presence of realtime events; this includes the process of updating the current schedule to face previously unknown events such as the arrival of new jobs (Hall et al. 2007), disruptions (Nouiri et al. 2018), perturbation of the originally given or estimated data (Hall and Potts 2010), etc. A recent and effective application of these concepts in the health care sector can be found in Ballestín et al. (2019). Two different reviews of the state-of-the-art of currently developing research on dynamic scheduling are given in Ouelhadj and Petrovic (2009) and Vieira et al. (2003).
The most common strategies (called predictive-reactive), when facing any unexpected change in the scenario, consider both the possibility of local adjustments and a whole recomputation of the current schedule with the aim of (locally) improving shop efficiency. Together with the latter objective, it is also of interest to measure how much the new schedule deviates from the original schedule. This concept (usually referred to as stability) is important since, typically, modification costs increase with the magnitude of such deviation, whereas big and frequent schedule changes often may cause undesired nervousness phenomena due to a lack of continuity.
From the pioneering works by Daniels and Kouvelis (1995) and Wu et al. (1993) up to the most recent papers (see, e.g., Detti et al. 2019;Niu et al. 2019), robustness is a widely adopted concept in scheduling and it is an alternative (pro-active) approach that tries to design a schedule which a priori guarantees a certain level of efficiency, given a set of possible scenarios. This way stability is preserved while performance is kept above a fixed level.
Indeed, our problem can be viewed in the framework of the so-called recoverable robustness, see Liebchen et al. (2009). A recoverable robust solution is not necessarily feasible in all scenarios of a robust optimization problem, but it can be made feasible by applying a (simple, quick) recovery algorithm to it. This concept has been investigated in several application contexts (mostly in transportation problems) and there is a limited literature also in scheduling. For instance, in van den Akker et al. (2018) an initial solution of a scheduling prob-lem is given and in each scenario some recovery actions are performed to make the solution acceptable again.
The algorithms presented in this work can be regarded as recovery algorithms to achieve certain objective benchmarks (rather than feasibility) in different problem settings which are illustrated below.
In the special rescheduling problem addressed in this paper, we consider several objective functions, namely total weighted completion time, maximum lateness, number of late jobs and weighted number of late jobs. We devise strictly polynomial-time optimization algorithms based on dynamic programming recursions for the first three objectives. In contrast, we prove that the problem is NP-hard when minimizing the weighted number of late jobs, but still permits a pseudopolynomial dynamic programming algorithm in that case. The remainder of this work is organized as follows: After a rigorous statement of the problem in Sects. 2, 3, 4 and 5 are devoted to the first three objective functions and describe the corresponding efficient solution algorithms. For the problem with the weighted number of late jobs objective, in Section 6, we prove its complexity and propose a pseudo-polynomial algorithm. Section 7 illustrates by a short experimental study the behavior of the rescheduling process depending on the stack size. Finally, concluding remarks are given in Sect. 8.

Problem statement
In this section, we give a formal statement of the problem under consideration and introduce the notation used throughout the paper. Hereafter, we use the term "job" to refer to both, a physical piece of material which is processed by some machine or resource and the process itself (characterized by a certain duration and possible additional data).
Let us consider a deterministic single-machine environment where we are given a set J of n jobs that have to be scheduled according to a regular, i.e., non-decreasing, objective function f (σ ) of the job completion times C j (σ ), j = 1, . . . , n. For such a schedule σ = σ 1 , σ 2 , . . . , σ n with σ k ∈ J , k = 1, . . . , n, if i ≤ j, we refer to the ordered set of jobs σ i , σ i+1 , . . . , σ j as the subsequence σ (i, j). Moreover, for each job j ∈ J we know its processing time p j and, possibly, a due date d j and a weight w j . As usual for scheduling problems, we will assume that all these values are nonnegative integers. However, this property will be required only for the dynamic programming algorithm in Sect. 6. Additionally, we are given an initial sequence σ 0 in which the n jobs of set J are numbered from 1 to n. So, σ 0 = 1, 2, . . . , n and we say that job j is placed in the j-th position to indicate that it is the j-th job of the sequence σ 0 . Clearly, if i, j ∈ J and i ≤ j, we have σ 0 (i, j) = i, i + 1, . . . , j .
In the problem addressed here, we look for a new job sequence σ such that (i) f (σ ) is minimum and (ii) σ can be derived from σ 0 by applying a (constrained) number of feasible moves.
Any move in this scheduling environment is performed by a physical device (e.g., a robot arm) that operates on a sequence of parts, each associated to one job, arranged in an ordered sequence along a line (e.g., on a moving conveyor). The initial sequence on this line corresponds to σ 0 . The considered device (i) picks up a job j; (ii) places j in the stack with bounded capacity S; (iii) possibly picks up other jobs and places them in the stack; (iv) picks the jobs from the stack, according to a LIFO policy, and places them back (on the conveyor) at a suitable position later in the sequence. We assume that there is always enough space between jobs to place even the whole content of the stack between any two jobs on the line. In this setting, moved jobs can only be postponed, as in fact the robot arm picks the jobs from the line while the conveyor feeding the processor moves ahead. Hence, reinsertion can only happen in a later position of the sequence.
Definition 1 A move i → j, i < j, consists of deleting job i from a given sequence and reinserting it immediately after all jobs of the subsequence σ 0 (i + 1, j). Figure 1 illustrates the process for three consecutive moves on a sequence σ 0 with n = 9 jobs. The picture emphasizes the characteristics of two types of feasible moves for the above mentioned physical device. A move 1 → 3 in which job 1 is placed immediately after job 3 is performed first. Then, moves 5 → 9 and 7 → 9 are done: Job 5 is loaded into the stack directly before 7, which is then extracted from the stack and placed just after job 9. After that, 5 is placed back on the line, right after 9 and 7. It is clear that the latter operations require that the stack capacity S is at least 2.
Observe that, if we start from σ 0 , due to the stack LIFO policy, Definition 1 is consistent even after a number of moves has been performed.
Following the above considerations, we are now characterizing the compatibility of two moves.
Definition 2 Two moves i 1 → j 1 and i 2 → j 2 with i 1 < i 2 are feasible if: (i) either j 1 < i 2 , i.e., i 1 < j 1 < i 2 < j 2 , and the moves are called sequential; (ii) or i 1 < i 2 < j 2 ≤ j 1 , and move i 2 → j 2 is nested in move i 1 → j 1 . Note that, as a consequence of Definition 1, it is easy to see that -when move i 2 → j 2 is nested in move i 1 → j 1 , i 2 precedes i 1 in the final sequence even if j 1 = j 2 ; -although the device picks jobs in increasing index order, the sequence σ , obtained after a set of feasible moves considering the LIFO policy of the stack, is independent from the particular order in which the moves are performed. -given a sequence σ = σ 0 , if there exists a set of feasible moves to reach σ starting from σ 0 , then such a set is unique.
We next define the level of a move: Definition 3 A move that does not contain nested moves is said to be at level 1. Recursively, a move m is at level > 1 if is the smallest value such that m contains feasible nested moves at level up to − 1. Clearly, a move at level is feasible only if ≤ S. In the example shown in Fig. 1, 1 → 3 and 5 → 9 are sequential moves while 7 → 9 is nested in 5 → 9. In particular, 5 → 9 is at level 2.
In the remainder of this paper, we adopt the following definition for a move.
Definition 4 A move i → j at level is denoted as (i, j, ). For notational convenience, we also define (i, i, ) for every level , meaning that job i is not moved at all.
Note that in our setting the stack capacity constraint imposes the index to be an integer within the range 1 to S, i.e., there must not be more than S moves nested inside each other.

Definition 5
The set of feasible schedules F S for the rescheduling problem where the stack capacity is limited by S, is comprised of all the schedules resulting from a set of feasible moves at levels up to a maximum of S starting from σ 0 .
In this paper, we consider the minimization of three classical objective functions in scheduling theory to evaluate the sequence obtained from σ 0 through the LIFO-constrained moves: total weighted completion time, maximum lateness (with extension to any regular function) and number of late jobs. For the latter, we consider both, the weighted and unweighted case.
For any feasible schedule σ of the jobs of J and any job j ∈ J , we define the following quantities: indicates if job j is late. Note that the completion time of job j in the initial sequence σ 0 is given by C j (σ 0 ) = j k=1 p k and its lateness by L j (σ 0 ). We indicate with P(i, j) = j k=i p k the total processing time of the subsequence σ 0 (i, j) and with W (i, j) = j k=i w k its total weight. Moreover, for a given subsequence σ (i, j), the maximum lateness within the subsequence is Furthermore, if φ j : R ≥0 → R, j ∈ J , are given regular functions, we denote the maximum of regular function objective as In accordance with the standard Graham's three field notation, we indicate the problems addressed in this paper as follows: 1|resch-LIFO| w j C j , 1|resch-LIFO|L max , 1|resch-LIFO| max , 1|resch-LIFO| U j and 1|resch-LIFO| w j U j where the last field refers to the particular objective we want to minimize in rearranging the given initial schedule σ 0 through the above described mechanism.
In this paper, we also consider the following special generalization of the above problems. Let ⊆ J be a given subset of movable jobs and consider as feasible solutions only the schedules obtained from σ 0 by a set of feasible moves (at levels up to a maximum of S), where only moves i → j with i ∈ are involved. Jobs from J \ cannot be moved, whereas jobs from may be moved but it is not mandatory to move them. In the remainder of the paper, we will refer to this variant as -constrained problem. Observe that our original rescheduling problems are special cases of these -constrained problems in which = J .

Total weighted completion time
We start our study by considering the minimization of the weighted sum of job completion times, for which we present a polynomial time dynamic program. First, we can observe that for any partition of a sched- . . , Q, the objective function can be expressed as follows: where the term f (1) σ (u q , v q ) denotes the total weighted completion time for the subsequence σ (u q , v q ), which in turn is the sum of the weighted completion times of the jobs in the subsequence. Denoting by J q the set of jobs of subsequence σ (u q , v q ), clearly we have: Consider the set M of all feasible moves (i, j, ) that allows to reach σ starting from σ 0 . Let M ⊆ M indicate the set of moves (i, j, ) which are not nested in any other move (h, k, ) ∈ M at a higher level > . By definition, the moves M are sequential moves. In M, we also include identity moves (i, i, 1) which correspond to not moving job i. (Clearly, parts of σ which are unchanged with respect to σ 0 , i.e., if the subsequence σ (i, j) = σ 0 (i, j), can be represented by a set of consecutive identity moves (k, k, 1) with k = i, . . . , j.) Let us denote M as follows: (3) plays a different role than Q in (2).) Because of the additivity principle (1), the cost f (1) (σ ) of schedule σ can be computed by adding-to the cost of σ 0 -the contributions of the r feasible moves of M. Note that in (3) each move (u q , v q , q ) may contain nested moves, so that its contribution depends on these nested moves as well. For instance, the sequential moves of M in the example illustrated by Fig. 1 are (1, 3, 1), (4, 4, 1) and (5, 9, 2). Move (5, 9, 2) contains the nested move (7, 9, 1), and therefore, its contribution must also account for the one of (7, 9, 1).
Hereafter, we present a dynamic programming algorithm for determining the optimal set of moves yielding a minimum cost schedule σ * , starting from σ 0 . The correctness of this algorithm straightforwardly follows from the following observation which corresponds to a standard optimality principle: In any optimal schedule σ * , there exists a partition as in (3), such that each subsequence in the partition is optimal for the subproblem containing only the jobs of that subsequence. The basic step of the dynamic program consists of computing the cost of a move (i, j, ), at level based on the knowledge of optimal costs for any subsequence of σ (i, j) in which the stack capacity is − 1.

Definition 6
The cost c(i, j, ) is defined as the minimum total weighted completion time variation when a move

when the stack capacity is equal to .
Observe that c(i, j, ) includes the optimal cost variation produced by all possible nested moves at lower levels, and hence, it takes into account information of all c(h, k, − 1) gives the optimal cost variation for the subproblem implied by i and j, c(i, j, ) considers the particular solution where the move i → j must be performed.
Hereafter, we show how to compute the variations in the schedule overall cost, for different moves and their combinations. We first consider the effect of single moves on the total weighted completion time. In this context, the following statement results directly from the definition of the completion time.

Observation 7
The completion time of each job preceding i and following j in the initial sequence σ 0 is not affected by the move (i, j, ).
Based on the initial schedule σ 0 , the cost variation m(i, j) due to moving job i after job j is expressed as The first term in (4) indicates the increase of the weighted completion time of job i, while the second term indicates the total decrease of the weighted completion times of the jobs in σ 0 (i + 1, j). In addition, because of the definition of the cost of a move (4), it is easy to verify the following: Observation 8 The effect of a move (i, j, ) at any level > 1 does not depend on the order of the jobs in the subsequence σ 0 (i + 1, j).
As a consequence, because of the LIFO constraint, the cost variation due to a single move (i, j, ) is always equal to m(i, j), for all possible levels .
As far as sequential moves are concerned, we recall that, owing to Eq. (1), the effect of two sequential moves (i 1 , j 1 , 1 ) and (i 2 , j 2 , 2 ), j 1 < i 2 , on the objective f (1) equals the sum of the effects of each move.
Moves at level = 1 cannot contain any nested moves, so the cost c(i, j, 1) of a move is equal to m(i, j). Obviously, when a job i is not moved, the associated cost is null and c(i, i, 1) = 0. Hence, we may give a recursive expression of the optimal cost variation for the subsequence σ 0 (i, j) as follows: Even when dealing with nested moves, i.e., for > 1, the cost variation of a set of moves is additive: Following the same line of arguments yielding to Observation 8 and Eq. (4), the overall effect on f (1) of two (or more) nested moves is equal to the sum of the effects of each move.
In order to compute the cost c(i, j, ) for a move (i, j, ) with ≤ , one clearly has to take into account the possibility of optimally rearranging the subsequence σ 0 (i + 1, j) with moves at levels lower than . Thus, after computing all optimal cost variations μ * (i, j, − 1) obtainable from a set of moves up to level − 1 for the subsequence σ 0 (i, j), it is possible to determine the (optimal) cost c (i, j, ). This in turn allows to compute the optimal cost variation μ * (i, j, ) for the subsequence σ 0 (i, j) at level . Formally, the following recursion holds: In Eq. (6), μ * (i, j, ) is computed in a similar way as in (5): Finally, the optimal solution value is found by computing μ * (1, n, S) such that the objective function value of the optimal schedule equals As for the computational complexity of the above dynamic program, we observe that the computation of all m(i, j), i.e., the costs at level = 1, requires O(n 2 ) time. For each level = 1, . . . , S and for each ordered pair of jobs (i, j), the algorithm must compute the cost c(i, j, ) of the corresponding move and the optimal subsequence cost μ * (i, j, ). Computing all c values requires O(n 2 ) time at each level, since each value is computed in O(1), while the computation of μ * (i, j, ) in Eq. (7) has a cost of O(n 3 ) time for each level . Hence, the overall complexity of the algorithm is O(n 3 S) which is upper bounded by O(n 4 ).
The results above can be summarized as follows.
Theorem 9 Problem 1|resch-LIFO| w j C j is polynomially solvable in time O(n 4 ).

Extension to the Ä-constrained problem
It is easy to handle the special case in which only jobs from a given subset ⊆ J of the jobs can be moved. For this purpose, we just make moves of jobs in extremely costly. Hence, we can still use Recursions (6) and (7) but with the following adjusted costs at level = 1 for a large enough constant M:

Maximum of regular functions minimization
In this section, we first focus on the minimization of the maximum lateness of the jobs and present a dynamic programming solution algorithm related to the one presented in the previous Sect. 3. We then discuss how the same algorithm can be used to solve the more general problem 1|resch-LIFO| max .

Minimization of maximum lateness
Recall that for a given schedule σ , we indicate by Here, the objective function for any partition of a sched- . . , Q, fulfills the following decomposition property: We first consider the effect of single moves on the maximum lateness. A straightforward consequence of Observation 7 is that a move (i, j, ) does not affect the lateness of any job preceding i and following j in the initial sequence σ 0 . Hence, even in this case, moves involving disjoint subsequences can be evaluated independently.
Differently from Eq. (4), we are not looking at the variation in the objective function due to a move (i, j, ), but rather at the optimal value that the objective function would take if move (i, j, ) were executed. Hence, we define the cost g(i, j, ) as the minimum value of the maximum lateness in subsequence σ (i, j) when moves up to level are done within it. For a single move (i, j, ), at any level, the lateness of all jobs in σ 0 (i + 1, j) decreases by p i while the lateness of job i increases by P(i + 1, j) = j k=i+1 p k . As a consequence, we may compute the cost at level 1 as follows: The term L i (σ 0 ) + P(i + 1, j) indicates the new lateness of job i while the term L max (σ (i + 1, j)) − p i indicates the new maximum lateness of the subsequence σ 0 (i + 1, j). We also define the cost of not moving a job i: Similar to the problem with total weighted completion time objective, also in this case the dynamic programming algorithm is based on computing the cost of a move (i, j, ), at level starting from the optimal costs of any subsequence of σ (i, j) at level − 1.

Definition 10
The cost λ * (i, j, ) is the value of the optimal solution of the subproblem restricted to subsequence σ 0 (i, j), when the stack capacity is equal to .
Note that, as before, for > 1 the computation of g(i, j, ) takes into account the lateness values produced by all possible nested moves at lower levels, i.e., the quantities g(h, k, −1) In general, different orders of the jobs in the subsequence σ 0 (i + 1, j) imply different effects of a move (i, j, ) on the objective function. Similar to the total weighted completion time case, when computing the cost g(i, j, ) we need to take into account the possibility of optimally rearranging the subsequence σ 0 (i + 1, j) with moves at lower levels. Thus, only after computing the optimal cost λ * (i + 1, j, − 1), obtainable from a set of moves at level at most − 1 for the subsequence σ 0 (i+1, j), it is possible to determine g(i, j, ).
Starting from the g(·) values at level , it is then possible to compute the optimal costs λ * (i, j, ) for each subsequence σ 0 (i, j) at level .
In conclusion, the following recursion holds: With Eq. (8), λ * (i, j, ) is computed in an analogous way as done in (5): In the above Eq. (9), λ * (i, i, ) always equals the "initial" value L i (σ 0 ) while, only when we consider a (proper) subsequence with more than one job, the actual costs associated with moves are accounted for. In particular, the optimal solution value λ * (i, j, ) can be computed as the best alternative among the solutions in which a move (i, k, ), k = i, . . . , j, is done: option k = i corresponds to a solution in which job i is not moved; if the best alternative is k = j, then λ * (i, j, ) = g(i, j, ); if i < k < j, the maximum lateness is the largest between the cost of move i → k at level at most and the optimal cost of the subsequence σ 0 (k + 1, j) at level at most . Finally, the optimal solution value is found by computing f (2) (σ * ) = λ * (1, n, S).
The computational complexity can be computed as in Section 3. The initialization, i.e., the computation of costs at level = 1, requires O(n 2 ) time. For each level = 1, . . . , S the algorithm must compute the costs g(·) and λ * (·) for each pair of jobs (i, j) (with i preceding j in σ 0 ). Computing all g values requires O(n 2 ) time at each level since each value is computed in O(1). The optimal costs λ * (i, j, ) can be computed, through Recursion (9)

Extension to maximum of regular functions objective
The correctness of the above dynamic programming algorithm is based on a decomposition principle, ensuring that parts of an optimal schedule are also optimal for the subproblems containing only the jobs of those parts. This in turn implies that an optimal subsequence is independent of its starting time. In other words, consider an optimal schedule σ * and one of its subsequences σ * (i, j) starting at, say, time t. Then, the same sequence σ * (i, j) is optimal for the subproblem pertaining only jobs {i, i + 1, . . . , j} (starting, e.g., at time t = 0). Unfortunately, when dealing with the minimization of the maximum of regular functions of the job completion times, such a property does not hold anymore. In fact, consider as an example the following trivial (sub-)problem with only two jobs {1, 2}, with p 1 = 1, p 2 = 4 and linear regular functions φ 1 (x) = 0.2x + 15, φ 2 (x) = 2x. The optimal schedule starting, e.g., at time t = 0 is 1, 2 , while when the starting time is t = 10, the optimal sequence becomes 2, 1 . As a consequence, no immediate generalization of the efficient dynamic programming approach illustrated Recursions (8) and (9) may guarantee optimality.
However, problem 1|resch-LIFO| max is still efficiently solvable by using a simple alternative procedure presented hereafter. The idea is to perform a binary search over the optimal objective values max , each time solving a suitable instance of 1|resch-LIFO|L max .
First observe that we may compute an interval in which the optimal value of the objective varies: (P(1, j))} = ω. (10) Let I be an instance of 1|resch-LIFO| max and¯ be a fixed target value for the optimal objective value of I . Clearly,¯ must be chosen in the interval [α, ω]. We are asking if there exist solution schedules for our instance of 1|resch-LIFO| max with optimal objective value not larger than¯ . We refer to such an instance as a YES-instance for .
For all jobs j ∈ J , compute a deadline τ j (¯ ) = max t≥0 {φ j (t) ≤¯ }. In general, since φ j (·) is nondecreasing, each such deadline may be efficiently computed in time, say, c. In the worst case, c is O(log( j∈J p j )); however, it is a reasonable to think of special cases where c is constant. Then solve an instance of 1|resch-LIFO|L max with due date d j = τ j (¯ ) for j ∈ J . Let σ * (¯ ) be an optimal solution and L max (¯ ) be the corresponding optimal objective value. If L max (¯ ) ≤ 0, then I is a YES-instance for¯ and σ * (¯ ) is a solution of 1|resch-LIFO| max with objective not larger than¯ .
Then, an optimal solution for our instance I of 1|resch-LIFO| max can be found by looking for the minimum value of¯ such that L max (¯ ) ≤ 0. As we already mentioned, this can be done by performing a binary search over the interval [α, ω] of Expression (10).
The overall complexity of the above procedure depends on the computational costs of the dynamic programming for the 1|resch-LIFO|L max problem, the deadlines computation and the binary search. In conclusion, assuming that we are able to efficiently compute the values φ j (·) and τ j (·) for all j ∈ J , and the values of suitable bounds for the objective α and ω, we may state that: Theorem 12 Problem 1|resch-LIFO| max is polynomially solvable in time O((n · c + n 4 ) log(ω − α)) where c is the cost for computing a job deadline.

Extension to the Ä-constrained problem
Similar to Sect. 3.1, in order to handle the special case where not all jobs are movable, the initialization in Recursion (8) is adjusted as follows (for a large enough constant M):

Minimization of the number of late jobs
This section provides a dynamic programming algorithm to minimize the number of late jobs, f (3) (σ ) = j∈J U j (σ ), where the quantity U j (σ ) assumes value 1 if and only if job j is late in schedule σ , i.e., if its lateness L j (σ ) is strictly positive.
Given a subsequence of a schedule, the number of late jobs in this subsequence depends not only on the processing times and due dates of the jobs in this subsequence, but generally also on its starting time. As a consequence, an (optimal) rearrangement of a subsequence that minimizes the number of late jobs depends on its starting time. This is illustrated in the following example: consider the sequence σ = 1, 2, 3 with p 1 = 7, p 2 = p 3 = 10, d 1 = d 2 = 25 and d 3 = 15. It is easy to see that, in order to minimize the number of late jobs in the subsequence σ (2, 3), the ordering 3, 2 should be preferred if the sequence starts at t = 0 (i.e., move 1 → 3 is performed), whereas for t = 7 (i.e., job 1 is not moved) the arrangement 2, 3 is better. However, the following result indicates that the relative order of the lateness values is independent from the starting time of a subsequence.
Observation 13 Let σ q (i, j) be a feasible arrangement of the subsequence σ (i, j) that minimizes the q-th largest lateness value, q = 1, . . . , j − i + 1. Then, σ q (i, j) does not depend on the starting time of σ q (i, j).
Note that in general the arrangements minimizing the q-th largest lateness are different for different values of q. However, when a subsequence is moved earlier (or delayed), all lateness values decrease (or increase) by the same amount, and hence, their order remains unchanged. Observation 13 holds for any possible definition of "feasible arrangement"; in particular, in this paper we clearly refer to the set of sequences resulting from a set of feasible moves at levels up to a given maximum.
In the reminder of this section, we refer to -rearrangement to indicate a feasible rearrangement of a subsequence that can be obtained by moves up to level .

Dynamic programming
By exploiting Observation 13, we subsequently devise a strongly polynomial time dynamic program for minimizing the number of late jobs.
In the dynamic program, we store for each subsequence of jobs not only the current number of late jobs, but we also record the minimum required reduction of the starting time for this subsequence to reach any number of late jobs, as we formally define below: Definition 14 For each i, j ∈ J with i ≤ j, m = 0, . . . , j − i and = 0, . . . , S, let s(i, j, m, ) be the minimum decrease of the starting time of the subsequence σ 0 (i, j) to obtain m late jobs in it when the subsequence can be rearranged with moves up to level .
Hereinafter, we will refer to this information as the state of the dynamic programming algorithm. Note that s(i, j, m, ) may also be negative (i.e., an increase of the starting time) if the number of late jobs in σ 0 (i, j) is smaller than m.
Definition 14 does not include the case m = j − i + 1 since the case where all jobs in a subsequence are late never requires reducing the starting time of the subsequence and thus is not relevant for a LIFO rearrangement.
Due to Observation 13, all -rearrangements of a subsequence σ 0 (i, j) that allow us to obtain m late jobs in it, when the subsequence is moved earlier by s , are dominated by the -rearrangements of σ 0 (i, j) that allow to obtain the same number of m late jobs in it when the subsequence is moved by s < s . By this dominance relation between rearrangements, we can restrict ourselves to recording the minimum decrease of the starting time 1 and thus avoid the combinatorial explosion of the problem. For every given number m, the value of state s(i, j, m, ) is obtained by taking the minimum reduction of the starting time over all possible moves (i, k, ) for k = i, . . . , j at some level ≤ that produce (at most) m late jobs in σ 0 (i, j). (Note that if k = i we are looking at an identity move, while if k > i we are considering all possible moves nested in i → k.) For each candidate k, we compute three multi-sets of lateness values, coming from three job subsets: namely the jobs nested in the move, the moved job and the other jobs. From the multi-set obtained by the union of these multi-sets, we select the minimum reduction in time that is needed to have m late jobs in σ 0 (i, j) for each value of m. In particular, some late jobs can be obtained from subsequence σ 0 (i +1, k) after reducing its starting time by p i ; some late jobs can be obtained from subsequence σ 0 (k + 1, j) whose starting time has not changed; and an additional late job is possibly the moved job i that is delayed by P(i + 1, k).
Hereafter, we use the notation max [q] (A) to indicate the q-th largest value in the multi-set of integer values A. To be precise, we refer to the q-th entry in the non-increasingly sorted multi-set.
At level = 0, the values s(i, j, m, 0) are evaluated on the initial sequence using the lateness values of the jobs in it. Let L(σ 0 (i, j)) be the multi-set of lateness values {L k (σ 0 ) : k ∈ σ 0 (i, j)}. With the notation introduced above, we initialize For levels ≥ 1, the recursive extension rule is as follows. For each subsequence σ 0 (i, j) and for each level = 1, . . . , S, we first consider all possible ways in which this subsequence can be feasibly rearranged with moves up to level . For this purpose, we compute the multi-set S(i, j, k, ) containing, for each possible move (i, k, ) at any level ≤ , the s(·) values for all numbers m = 0, . . . , j − i of late jobs: In (12), we distinguish the union of three multi-sets: The first one contains k − i values computed from the non-dominated ( −1)-rearrangements of the subsequence σ 0 (i +1, k) whose jobs, due to the move i → k, start earlier by p i time units. The second multi-set refers to the s(·) values of the jobs from k + 1 to j whose starting times are not affected by the move. Finally, the third term corresponds to the lateness of job i after move i → k is performed. Recall that Observation 13 guarantees that a ( − 1)-rearrangement of subsequence σ 0 (i + 1, k) producing (at most) m late jobs does not change when the subsequence is moved earlier by p i . The (m + 1)-largest entry of the multi-set S(i, j, k, ) represents the necessary amount of time by which we need to bring forward σ 0 (i, j) after a move (i, k, ) with ≤ , in order to have m late jobs. Thus, the value of the new state corresponds to the move i → k such that this decrease of the In computing the s(i, j, m, ) values, we keep a specific order for i, j, and : This is illustrated in the Recursion procedure of Algorithm 1. The optimal solution value, f (3) (σ * ) = j∈J U j (σ * ), is finally given by min{m : s(1, n, m, S) ≤ 0}.
To illustrate the non-trivial handling of multi-sets in the dynamic programming recursion, we give the following example.
Example Consider a schedule σ 0 = 1, 2, 3, 4 with 4 jobs. The respective processing times and due dates are given in Table 1. Since the example is intended to illustrate how a state value is computed, we restrict ourselves to the case S = 1. An analogous procedure is to be used for larger values of S.
In order to compute the minimum number of late jobs in the sequence σ 0 with moves up to level 1, we have to calculate all state values s (i, j, m, ) with i, j ∈ {1, 2, 3, 4}, i ≤ j, m = 0, . . . , j − i and ∈ {0, 1}.
At level = 0, the initialization according to (11) needs to be performed. Since the lateness value of each job in σ 0 is already given in Table 1, the s(·) values can easily be obtained. For example, s(1, 4, 2, 0) corresponds to the third largest value in the multi-set {30, 20, 20, −20} which is 20.
All state values at level 0 are presented in Table 2.
At level = 1, the subsequences are examined in a specific order as shown by the rows in Table 3: In an outer loop, index j spans the range 1 to 4 while in an inner loop index i runs from j down to 1. In order to compute s(i, j, m, 1) with (13), we first have to compute S(i, j, k, 1) for all k ∈ σ 0 (i, j) according to (12).
As S(i, j, k, 1) is the union of three multi-sets, each of the three sets is given separately in the middle part of Table 3: On the left, indicated by s(i + 1, k, u, 0) − p i from (12), the lateness values of the jobs in the subsequence, which are moved to an earlier starting time, are shown. In the middle, the lateness values s(k + 1, j, u, 1) of the jobs in the later part of the subsequence are given. These values come from the previous rows in the table. For this reason, the s(·) values need to be evaluated in the order stated above. On the right, the lateness value C k (σ 0 ) − d i corresponding to the moved job is given.
After calculating S(i, j, k, 1) for all k ∈ σ 0 (i, j), the state values s(i, j, m, 1) can be obtained from (13). For this purpose, the values in the multi-set S(i, j, k, 1) are sorted in non-increasing order, as shown in the right part of Table 3. The value s(i, j, m, 1) is then obtained by talking the minimum value of all (m + 1)-largest values from the multi-sets S(i, j, k, 1). Using the table, this can be performed by calculating the minimum value of the corresponding j −i +1 rows in the column with the corresponding m-value. For example, s(1, 4, 2, 1) corresponds to the minimum of the multi-set {10, −5, −5, −5} which is −5.
As we can see in the last row of Table 3, the optimal solution for stack capacity S = 1 has two late jobs since m = 2 is the minimum value which fulfills s(1, 4, m, 1) ≤ 0, i.e., a schedule with two late jobs can be obtained at level = 1 starting at time 0. In this example, multiple optimal schedules exist. One of them, for instance, is the schedule σ = 2, 1, 3, 4 in which jobs 3 and 4 are late. It can be obtained by the single move 1 → 2.  s(i, j, m, 1) for all i, j ∈ {1, 2, 3, 4} with i ≤ j and m ∈ {0, . . . , j − i}

Algorithmic realization of the dynamic program
In this section, we illustrate a straightforward implementation of the algorithm sketched in Section 5.1. The corresponding pseudocode is presented in Algorithm 1. The recursion requires the generation of the states from level = 0 up to S to ensure that the effects of moves nested in any move of level have already been examined. Furthermore, for each level, the subsequences are examined in a given order: In an outer loop (Steps 8-17), the index j spans the range 1 to n while in an inner loop the index i runs from j down to 1 (Steps 9-17). This guarantees that when move (i, k, ) is considered, the effects of all moves (i , k , ) with k < i ≤ k , have already been computed. For a given triple (i, j, ), all multi-sets S(i, j, k, ), k = i, . . . , j, are temporarily stored in the lists S k . Note that Steps 12-14 implement the union of the three multi-sets of Equation (12) and the procedure Append, used in the algorithm, simply adds an element to the end of a linked list.
The running time complexity of Algorithm 1 can be analyzed as follows. The main computation, executed in Loop 1 (Steps 10-14) and Loop 2 (Steps 15-17) of procedure Recursion, is performed O(Sn 2 ) times, namely for all levels and over all ordered pairs (i, j). Both, Loop 1 and Loop 2, have total cost O(n 2 ) since each iteration in those loops requires O(n) time. Thus, the overall worst-case time complexity is O(n 4 S) which can be bounded by O(n 5 ). The above discussion can be summed up in the following theorem.

Extension to the Ä-constrained problem
To deal with the problem where not all jobs are movable, we need to reconsider Expressions (11) and (13) since the multisets S(i, j, k, ) have no meaning anymore for i ∈ J \ . In particular, Recursion (13) can be rewritten as follows: Since job i cannot be moved, its lateness value is C i (σ 0 )−d i , whereas the necessary reductions of the starting times for the subsequence σ 0 (i + 1, j) are the already computed values of the states s(i + 1, j, u, ), u = 0, . . . , j − i − 1.

Minimization of the weighted number of late jobs
Here, we deal with a generalization of the problem introduced in the previous Sect. 5, and consider different job priorities. We therefore introduce a cost, associated to each job, which is paid if that job is late. This type of objective is studied in a number of papers (see, e.g., Baptiste 1999;Blazewicz et al. 2005). We first prove that the resulting problem, namely 1|resch-LIFO| w j U j , is NP-hard and then present a pseudo-polynomial exact solution algorithm based on dynamic programming.
Proof We consider the following decision problem D: Given an instanceĪ of 1|resch-LIFO| w j U j and an integer Q, is there a feasible solution σ ofĪ such that j w j U j (σ ) ≤ Q?
We prove that D is NP-complete, thus proving the hardness of 1|resch-LIFO| w j U j . The reduction is from Equal-Cardinality Partition: Given a set of 2n positive integers {a 1 , a 2 , . . . , a 2n }, is there a subset A of the index set A = {1, . . . , 2n} with i∈A a i = i∈A\A a i and |A | = n? Given an instance I of Equal-Cardinality Partition, we can build an instanceĨ of D as follows. There are 2n jobs, and for each job i = 1, . . . , 2n we set w i = p i = a i and d i = 1 2 2n k=1 a k . Moreover, the stack capacity is S = n and Q = 1 2 2n i=1 a i . It is easy to observe thatĨ is a YES-instance of D, i.e., there is a schedule σ such that j w j U j (σ ) ≤ Q, if and only if I is a YES-instance of Equal-Cardinality Partition.
Note that if such a schedule σ exists, then it can be obtained by moving at most n jobs (the late ones) to the right end of the schedule.

Dynamic programming
In this section, we show that a pseudo-polynomial algorithm exists for 1|resch-LIFO| w j U j , hence complementing the result given in Theorem 16.
First of all, let us recall that all data (i.e., processing times, weights and due dates) are positive integer values. Unlike the dynamic program for the unweighted case, where for the optimal -rearrangement of each subsequence the minimum reduction of the starting times for different number of late jobs is recorded, we now store the minimum weighted number of late jobs for different reductions of the starting time.
Definition 17 For each i, j ∈ J with i ≤ j, t = 0, . . . , P(1, i − 1), and = 0, . . . , S, let r(i, j, t, ) be the minimum weighted number of late jobs that can be achieved by rearranging the subsequence σ 0 (i, j) with moves up to level , after decreasing the starting time of the subsequence by t.
As an initialization, we have: Similar to the algorithm for the unweighted case, in the recursion, the value of state r (i, j, t, ) is obtained by taking the minimum weighted number of late jobs over all possible moves (i, k, ) for k = i, . . . , j at some level ≤ . The effect of such a move is given by the sum of (at most) three terms expressing the weighted number of late jobs of the optimal ( − 1)-rearrangement of subsequence σ 0 (i + 1, k) with a starting time decreased by p i , the weighted number of late jobs of the optimal -rearrangement of subsequence σ 0 (k +1, j) and the weighted number of late jobs contributed by the moved job i which is given by Therefore, the value for the new state can be computed with the following recursion: for all i, j ∈ J , i ≤ j, for all t = 0, . . . , P(1, i − 1) and for all = 1, . . . , S where The optimal solution value, f (4) (σ * ) = j∈J w j U j (σ * ), is found by computing r (1, n, 0, S).

Algorithmic realization of the dynamic program
The pseudocode in Algorithm 2 straightforwardly follows the approach described in the previous section. The recursion requires, analogous to Algorithm 1, the generation of the states from level = 0 up to S. Additionally, for each level , the subsequences σ 0 (i, j) are also examined in two loops where index j runs from 1 up to n in an outer loop, while in an inner loop index i runs from j down to 1 to ensure that certain states are already computed.
It is easy to see that the proposed algorithm has a pseudo-polynomial running time of O(n 3 S P) where P = P(1, n) = j∈J p j is the sum of the processing times of all jobs.
Of course, Algorithm 2 can also be used for the unweighted case (with w j = 1 for all j ∈ J ). Clearly, we then still have a pseudo-polynomial running time instead of the strongly polynomial running time stated in Theorem 15.

Extension to the Ä-constrained problem
To solve the -constrained problem, we can still use Equations (14) as an initialization but we need to adapt Recursion (15) as follows: as in Expression (15), otherwise, for all i, j ∈ J , i ≤ j, for all t = 0, . . . , P(1, i −1) and for all = 1, . . . , S. If job i is not movable, its total weighted number of late jobs, depending on t, is r (i, i, t) and the weighted number of late jobs for the subsequence σ 0 (i +1, j) is simply the already computed value r (i + 1, j, t, ).

Alternative dynamic program
An alternative solution approach for 1|resch-LIFO| w j U j can be derived by generalizing Algorithm 1 to the weighted setting. In this case, we define s(i, j, m, ) as a generalization of s (i, j, m, ) where m now denotes the weighted number of late jobs. Consequently, variable m can take every weight value of the objective function, and therefore can be upperbounded by the value W = W (1, n) = j∈J w j .

Definition 18
For each i, j ∈ J with i ≤ j, m = 0, . . . , W (i, j) and = 0, . . . , S, let s(i, j, m, ) be the minimum decrease of the starting time of the subsequence σ 0 (i, j) that ensures a value of at most m for the weighted number of late jobs when the subsequence can be rearranged with moves up to level .
The generalization of Eqs. (11) to (13) is as follows: the initialization for all i, j ∈ J , i ≤ j, and for all m = 0, . . . , W (i, j) − 1 is given by The recursive extension rule for all i, j ∈ J , i ≤ j, m = 0, . . . , W (i, j) − 1 and = 1, . . . , S is with the modified multi-set Obviously, this generalization of the algorithm sketched in Sect. 5.1 results in a worst-case computational complexity of O(n 3 S W ) which can be bounded by O(n 4 W ). Summing up the above argumentation and those of Sect. 6.3, we obtain the following theorem.

Empirical analysis of the stack size effect
In this section, we illustrate the effect of rescheduling and in particular the influence of the stack size for the three polynomial time algorithms presented in Sects. 3 to 5. We do not report running times. We only observe that the dynamic programming algorithms show quite small deviations in running times for instances of the same size. As a test bed, we follow the data generation scheme by Potts and Van Wassenhove (1988). We choose processing times and weights independent and identically, uniformly distributed with p j ∼ U (1, 100) and w j ∼ U (1, 100). For two parameters d and d u we choose d j ∼ U (P(1, n) d , P(1, n) d u ). We consider four choices for d , namely d ∈ {0.2, 0.4, 0.6, 0.8}, and all possibilities for d u ∈ {0.2, 0.4, 0.6, 0.8, 1.0} with d ≤ d u , which yields 14 pairs of parameter values. For the number of jobs, we take n = 50 and n = 100. For each of the 28 resulting classes of instances, 20 instances were randomly generated, i.e., 560 instances in total.
The goal of our analysis is twofold: We want to analyze the potential improvement of the objective function obtained through rescheduling and we want to illustrate the utilization of the stack. Naturally, both aspects strongly depend on the Note that for practical applications in a production setting, the LIFO stack can be expected to be of moderate size with S ≤ 10, but for the empirical analysis we consider also larger values of S. It is also clear that S does not depend on the number of jobs. The results of our tests are given in Figs. 3, 4 and 5. All values are taken as averages over the 280 instances for n = 50 and n = 100, respectively.
The two graphs in the upper row of each figure describe the effect of rescheduling on the solution. In Figs. 3a, 4a and 5a, we give the gap between the solution obtained from rescheduling under LIFO constraints with a certain stack size (given on the x-axis) and the optimal schedule (obtained by completely reordering the given jobs). For 1|resch-LIFO| w j C j , the gap in Fig. 3a is the difference relative to the total weighted completion time of an optimal schedule expressed in percent. For 1|resch-LIFO|L max , it is not obvious how to scale the difference to the optimal schedule since the latter could have a positive, zero or negative maximum lateness. Thus, we take the difference between lateness after rescheduling and lateness of an optimal schedule and divide it by C max = P(1, n), see Fig. 4a. Finally, for 1|resch-LIFO| U j the difference of the number of late jobs is given as an absolute value in Fig. 5a (note that the optimal value might be zero). It can be seen that there is a certain limit on the effect reachable by rescheduling, e.g., for total weighted completion time the gap hardly gets below 20%. This is possibly due to the LIFO constraint.
In Figs. 3b, 4b and 5b, we give the number of moves, i.e., the total number of jobs inserted into the stack during the rescheduling process. As can be expected, a larger stack size permits much more improvement of the solution and reschedules a larger proportion of the jobs. But from a certain stack size, the objective improves only marginally and thus also the number of moves ceases to grow.
The two graphs in the lower row of each figure describe the stack utilization. In Figs. 3c, 4c and 5c, the maximum stack utilization is given, i.e., the largest number of jobs contained in the stack at any time during the rescheduling process. It turns out that for the total weighted completion time the stack size is almost always fully exploited at some point of the execution. This is not the case when minimizing maximum where a close to optimal solution is reached with a moderate stack size, but further improvements are reachable only for a few instances as the stack size increases. If the number of late jobs is minimized, the stack size can be mostly fully exploited for the larger instances with n = 100, while for n = 50 an almost optimal solution is reachable even with S ≈ 15 (as can be seen from Fig. 5a), and thus, the stack is not fully utilized (see Fig. 5c). Finally, Figs. 3d, 4d and 5d show the average stack utilization. This means that we track the number of jobs contained in the stack in each of the n − 1 steps of the rescheduling process and take their average. Clearly, this includes a certain phasing-in and phasing-out effect since the empty stack only starts accepting jobs at the beginning and has to be empty again until the end of the sequence. The concave shape of the corresponding figures is due to this effect which is naturally much stronger for n = 50 than for n = 100. It turns out that for maximum lateness the average stack utilization is considerably smaller than for total weighted completion time (compare Figs. 3d and 4d) with number of late jobs as a close follower. We believe that this is due to the fact that for total weighted completion time the optimal solution is unique (for distinct input values) while for the other two objectives there usually exist various different sequences with the same solution value. Once an optimal or very good solution value is reached, further rearrangements of the sequence are not beneficial any more.

Conclusions
In this paper, motivated by questions arising in manufacturing applications, we study the problem of rearranging a given sequence of jobs on a single machine in order to minimize one of four different objectives. We rely on the standard scheduling parameters of a job, namely processing time, weight (importance) and due date. From a practical point of view, also operating costs arising from the rearrangement steps, in particular energy consumption, could be taken explicitly into account.
The new sequence can be obtained respecting certain technological constraints: In particular, our jobs are associated to physical parts, sequenced on a conveyor that feeds a pro- cessing resource, which can be picked up by a robot. A job taken from the conveyor by the robot is first put into a buffer and then placed again on the conveyor in a later position of the original sequence. The buffer is managed as a stack with limited capacity so the last job entering the buffer is the first taken by the robot to be put down again on the conveyor. Due to this LIFO mechanism, only a certain set of sequences can be reached starting from the initial one and this set constitutes all the feasible solutions of our problems. Our contribution is focused on settling the computational complexity and providing exact solution algorithms. In particular, we are able to provide strongly polynomial (dynamic programming) solution algorithms for the minimization of (i) total weighted completion time of the jobs, (ii) maximum of regular functions of the completion times, in particular maximum lateness, of the jobs, and (iii) number of late jobs. We also prove that (iv) if we want to minimize the weighted number of late jobs, then the problem becomes (weakly) NPhard. For the latter problem, we present a pseudo-polynomial solution algorithm (again based on a dynamic program).
Future research should consider an empirical study concerning both the characterization of optimal solutions, that may be obtained starting from different input sequences, and the performance of exact solution algorithms in terms of numerical efficiency, with possible comparisons with alternative enumeration schemes.
In more general terms, it would clearly be interesting to consider other regimes for buffer management. From a practical point of view, the most relevant setting would be a queue environment implied by a FIFO mechanism. Of course, also a random access buffer where any job can be taken from the buffer, may be well justified, although technically more complicated. These two aspects will be subject of future research. Moreover, it would also be interesting to consider alternative performance figures. We dealt with the four most common, standard objectives functions, but in the future also other choices might be relevant, in particular in the context of a real-world application (Li et al. 2021).
Funding Open access funding provided by Università degli Studi Roma Tre within the CRUI-CARE Agreement. This study was partially funded by MIUR PRIN Project AHeAD (Efficient Algorithms for HArnessing Networked Data), by the University of Graz under the Field of Excellence "COLIBRI" and by the Regione Lombardia, grant agreement n. E97F17000000009, Project AD-COM.