Single-machine rescheduling problems with learning effect under disruptions

Rescheduling in production planning means to schedule the sequenced jobs again together with a set of new arrived jobs so as to generate a new feasible schedule, which creates disruptions to any job between the original and adjusted position. In this paper, we study rescheduling problems with learning effect under disruption constraints to minimize several classical objectives, where learning effect means that the workers gain experience during the process of operation and make the actual processing time of jobs shorter than their normal processing time. The objectives are to find optimal sequences to minimize the makespan and the total completion time under a limit of the disruptions from the original schedule. For the considered objectives under a single disruption constraint or a disruption cost constraint, we propose polynomial-time algorithms and pseudo-polynomial time algorithms, respectively.


1.
Introduction. Learning effect in manufacturing process means that many similar products or parts are produced continuously and repetitiously, which makes the manufacturer/worker to perform subsequent operating faster than before. The impact of learning on productivity in manufacturing was first observed by Wright [22], who used a learning curve to model the aircraft industry. Recently, Anzanello and Fogliatto [1] provided a good review of learning curve. The concept of learning effect was first introduced into machine scheduling problems by Biskup in 1999. For several scheduling problems with learning effect, Mosheiov [17] gave several examples to demonstrate that the optimal schedules are very different from the corresponding classical versions of them. Bachman and Janiak [4] considered some single-machine scheduling problems with a job's processing time depended on the position of this job in a sequence. What's more, Biskup [6] surveyed most of articles recently published about machine scheduling problems with learning effects. Recently, Wang et al. [21] considered single-machine scheduling problems with controllable processing time, truncated job-dependent learning and deterioration effects to minimize a cost function containing several classical objectives and total resource cost. There are still many interesting topics to be focused, readers can refer to Yin et al. [25], Vahedi-Nouri et al. [20] and Cheng et al. [8], etc.
In actual manufacturing environment, unforeseen disruptions often occur, such as the arrivals of new jobs, the change of order priority and the change of release dates, etc. Such uncertainties create a need for rescheduling jobs to meet the emergent request. Rescheduling means to schedule the jobs again together with a set of new jobs so as to minimize objectives. There are many researchers to study rescheduling problems. For example, Hall and Potts [11,12] considered a rescheduling problem in a single-machine setting with newly arrived jobs to minimize the maximum lateness and the total completion time under a limit of disruptions. Azizoglu and Alagoz [3] considered the rescheduling problems with a period of unavailability on one machine due to disruption. They traded off between two conflicting criteria: total flow time and the number of disrupted jobs, and illustrated that all the efficient schedules with respect to the two criteria can be found in polynomial time. Yang [24] studied a single-machine rescheduling problem with the arrivals of new jobs and compressed processing time. Yuan and Mu [26] developed a single machine rescheduling problem with release dates to minimize makespan under the maximum sequence disruption. While, Zhao and Tang [28] studied two single-machine rescheduling problems with linear deteriorating jobs under a disruption to minimize the total completion time, which can be solved in polynomial time. Liu and Young [16] provided three approximation algorithms to study a single-machine rescheduling problem to minimize some cost objectives while the rescheduled jobs without excessively disrupting the original schedule.
In recent years, there are also many research study rescheduling problems in multiple-machine settings. Ozlen and Azizoglu [18] considered a unrelated parallel machines rescheduling problem with a disruption on one of the machines, they provided polynomial-time algorithms to minimize total disruption cost among the minimum total flow time. Chiu and Shih [9] considered an integrated model that analyzed both preventive maintenance and rush orders in a two-machine flow shop using two different rescheduling methods. Katragjini et al. [14] developed rescheduling algorithms to consider flow shop rescheduling layouts and generated three types of disruption that interrupted the original schedules simultaneously. Liu and Zhou [15] investigated an identical parallel-machine rescheduling problem, and proposed two polynomial time algorithms for lexicographically optimizing two conflicting rescheduling criteria: the total completion time and the disruption cost. Sun et al. [19] investigated a hybrid flow shop rescheduling problem to minimize the total weighted completion time, the total waiting time, and the difference in the number of operations processed on different machines for different stages in the original schedule and revised schedule. There are also other references to be focused on, such as, Filar et al. [10], Hoogeveen et al. [13], Zhang et al. [27] and Arnaout [2], etc.
The above references few attempted to take into account learning effect in rescheduling problems. However, there are many applications in production or service operation, i.e., emergent orders and emergency patients, etc, which should be dealt quickly so as to decrease loss. In this paper, we consider single-machine rescheduling problems with learning effect under disruption constraints to minimize the makespan and the total completion time of the new jobs being integrated into the schedule, respectively. For such problems, we propose polynomial-time algorithms to find the optimal job sequences, respectively.
The remainder of this paper is organized as follows. Notations and formulation of the considered problem are described in Section 2. Section 3 provides structural results to be useful for the proposed problems, and studies several rescheduling models with a single disruption constraint. The rescheduling models with several practical measures of disruptions for minimizing the makepan and the total completion time will be considered in Section 4. Finally, concluding remarks and ideas for future research are given in Section 5.
2. Formulation and notations. A set of original jobs £ O = {J 1 , ..., J n O } is to be processed on a single-machine setting without being allowed preemption. We assume that the jobs in £ O have been scheduled optimally to minimize some classical objective and π * is an optimal schedule. Let £ N = {J n O +1 , ..., J n O +n N } denote a set of new jobs which will be inserted to be processed along with jobs in £ O , write as £ = £ O ∪ £ N . Let n = n O + n N . If Job J j ∈ £ is processed at rth position in a sequence, its actual processing time is denoted as p jr = p j r α , where −1 ≤ α < 0 is the learning index of all jobs, and p j denotes normal processing time. Suppose the new jobs arrive together at time zero after that the sequence of the jobs in £ O has been determined without being processed. For any schedule σ of the jobs of £, we define the following notations: • C j (σ) denotes the complete time of job J j ∈ £.
• J i ≺ J j denotes the normal processing time of job J i and J j satisfies p i ≤ p j .
• D j (π * , σ) = |r 2 − r 1 | denotes the position disruption of job J j ∈ £ O , i.e., if J j is the r 1 th job to be processed in π * and the r 2 th job to be processed in σ, respectively.
3. Rescheduling problem with a single disruption constraint. In this section, we study rescheduling problems with learning effect under a single disruption constraint. Before discussing the models, we give several lemmas which will be used in the subsequent sections.
an optimal schedule can be obtained by sequencing the jobs in a non-decreasing order of p j (SPT-rule).
From Hall and Potts [11], we know that if a rescheduling problem has the (SPT, SPT) property, then a polynomial-time algorithm can be designed. Therefore, if the objective is to minimize the makespan or the total completion time, we assume that the jobs in £ O are indexed and sequenced in SPT-order in π * , i.e. p 1 ≤ p 2 ≤ ... ≤ p n0 for all objectives. In the following, we will show that the SPT-rule apply to the several considered rescheduling problems. Let £ M = {J j ∈ £ N |p j < p n0 }, obviously, we have the following lemma. Lemma 3.2. For problems 1|p jr = p j r α , D max (π * ) ≤ k|γ and 1|p jr = p j r α , ∆ max (π * ) ≤ k|γ, where γ ∈ {C max , C j } under the job set (£ O , £ N ) can be polynomially reduced to the corresponding problem under the job set (£ O , £ M ). Lemma 3.3. For Problems 1|p jr = p j r α , D max (π * ) ≤ k|γ and 1|p jr = p j r α , ∆ max (π * ) ≤ k|γ, where γ ∈ {C max , C j }, all have an optimal schedule with no idle time between jobs, and (i) a schedule for problem 1|p jr = p j r α , D max (π * ) ≤ k|γ is feasible if and only if the number of jobs of £ N scheduled before the last job of £ O is no less than k; (ii) a schedule for problem 1|p jr = p j r α , ∆ max (π * ) ≤ k|γ is feasible if and only if the total actual processing time of jobs of £ O scheduled before the last job of £ O is no less than k.
Proof. The process of proof is similar to that of Lemma 1 in Hall and Potts [11], and omitted here. Proof. For jobs in £ O , suppose there exists an optimal schedule σ * in which all jobs are sequenced in non-SPT order. Let J i be the job with the smallest index that appears relatively later to other jobs of £ O in σ * than in π * , and J j (i < j) be the last job of £ O that precedes job J i in σ * . Suppose jobsJ 1 ,J 2 , ...,J h are processed between J j and J i . Let the starting time of job J j be s and be scheduled in the rth position in σ * . By interchanging the position of job J j and job J i to get a new scheduleσ, and the starting time of job J i is s which is scheduled in the rth position inσ, we have Since i < j, which implies p i < p j , then we have Therefore, jobsJ 1 ,J 2 , ...,J h are completed earlier inσ than in σ * , which means that the value of corresponding objective function does not increase after the interchange. On one hand, since the job J i is processed at ith position in π * and job J j at jth position, we suppose that job J j is processed at r 1 th position inσ. If and C i (π * ) < C j (π * ), then, we have ∆ j (π * ,σ) < ∆ i (π * , σ * ) and ∆ i (π * ,σ) < ∆ i (π * , σ * ). Therefore, we have Based on the above analysis,σ is a feasible and optimal sequence.
A finite number of repetitions of this argument show that there exists an optimal schedule in which the jobs in £ O are sequenced in SPT order as in π * , and a similar job insertion argument establishes that the jobs in £ N can also be sequenced in SPT order. Obviously, an optimal schedule should not be no-idle time in π * ; otherwise, by removing this idle time maintains feasibility and decreases the value of objective function.
From lemma 3, we know that there are at most k jobs in £ N to be sequenced before the last job in £ O . Thus, By referring to the (SPT, SPT) property and lemma 4, we propose the following algorithm.

Algorithm I
Step 0. Set the value of k (≥ 0).
Step 1. Index jobs of £ N in SPT-order: Step 2. If p n O +1 > p n O , then goto Step 5; otherwise, choose m(≤ k) feasible jobs.
Step 3. Sequence jobs J 1 , ..., J n O , J n O +1 , ..., J n O +m in SPT-order in the first n O + m positions, and update the job set £ O .
Step 4. Sequence jobs J n O +m+1 , ..., J n O +n N in SPT-order in the last n N − m positions, and update the job set £ N .
Step 5. Sequence the job sets of £ N following £ O .
Obviously, from Step 1, we know that sequencing n N jobs requires O(n N log n N ) time. In Steps 3 and 4, it requires O(n) time to merge the first m jobs of the SPT-ordered jobs of £ N with the jobs of £ O as sequenced in π and then place the last n N − m jobs of the SPT-ordered jobs of £ N at the end of the schedule. Therefore, the complexity of Algorithm I is O(n + n N log n N ), and we have the following proposition.
Similarly, we consider problem 1|p jr = p j r α , D j (π * ) ≤ k| C j . Lemma 1 and Lemma 4 show that a local optimal partial schedule can be found by merging several appropriate jobs of £ O and £ N in SPT-order, respectively. An optimal merging can be performed subject to the given constraint on the total sequence disruptions by the following dynamic programming algorithm.

Algorithm DP
Step 0. Set the value of k (≤ n O n N ).
Step 1. Index jobs of £ N in SPT-order: Step Step 3. Let f (i, j, δ)= minimum total completion time of a partial schedule for jobs J 1 , J 2 , ..., J i and J n O +1 , ..., J n O +j , where the total sequence disruption is equal to δ. (Boundary condition f (0, 0, 0 Step 5. Optimal solution value min 0≤δ≤k f (n O , n N , δ).
Obviously, for the recurrence relation in Step 4, the term f (i − 1, j, δ − j) corresponds to the case where the partial schedule ends with job J i ∈ £ O , and j jobs of £ N appear before job J i in such a partial schedule. The increase in the total sequence disruptions is equal to j. The term f (i, j − 1, δ) corresponds to the case where the partial schedule ends with job J n O +j ∈ £ N . The number of the total sequence disruption is still equal to j. Thus, we have For problem 1|p jr = p j r α , D j (π * ) ≤ k|C max , we only modify the recurrence relation of the above algorithm into f (i, j, δ) Similarly, we have the following proposition.
Proposition 3. An optimal schedule for problem 1|p jr = p j r α , D j (π * ) ≤ k|C max , can be found in O(n 2 O n 2 N ). Similarly, we consider 1|p jr = p j r α , ∆ max (π * ) ≤ k|γ, where γ ∈ {C max , C j }. The (SPT, SPT) property of Lemma 4 and Lemma 1 shows that an optimal schedule is found by merging the SPT-order lists of jobs of £ O . We know that C j (π * ) can be obtained by sequencing the j jobs in £ O in SPT-order. Because of the (SPT, SPT) property of Lemma 2, we have C j (σ) ≥ C j (π * ) for J j ∈ £ O . Thus, the constraint ∆ max (π * ) ≤ k reduces to C j (σ) ≤ C j (π * ) + k, equivalently, which means job J j ∈ £ O with a deadlined j = C j (π * ) + k andd j = ∞ for job J j ∈ £ N , and it is obvious thatd 1 ≤d 2 ≤ ... ≤d n O . Once the deadlines have been computed, the problem can be denoted as 1|p jr = p j r α ,d j |γ, where γ ∈ {C max , C j }. Since Smith (1956) solved the problem 1|d j | C j by a backward procedure in which a feasible job with the largest due-date is assigned to the last unfilled position in a sequence, we propose an algorithm through modifying Smith's rule to solve the problem.
Step 1. Index jobs of £ O in SPT-order: J 1 ≺ J 2 ≺ ... ≺ J n O , and £ N in SPTorder: J n O +1 ≺ J n O +2 ≺ ... ≺ J n O +n N , then reindex the jobs of £ in SPT-order and let ζ be the set of jobs sequenced after job J n O .
Step 2. If job J n O is sequenced before job J n O +1 , then terminate; otherwise, let job J n O +j be the last job of £ N that sequenced before job J n O .
Step 3. Compute C j (£) for all jobs of £ O , if C j (£) ≤d j , goto Step 5; otherwise, remove job J no+j from £.
Step 5. Sequence the jobs of ζ in SPT-order after £ and obtain the optimal schedule. Proposition 4. An optimal schedule for problem 1|p jr = p j r α , ∆ max (π * ) ≤ k|γ, where γ ∈ {C max , C j }, can be found in O(n + n N log n N ).
Proof. The jobs in £ N are indexed in SPT-order, so that the job to be scheduled in the last unfilled position in the sequence is either the last unscheduled job in π * or the last unscheduled job among the SPT-indexed in £ N . Because the ordering of the jobs of £ N requires O(n N log n N ) time and the schedule construction requires O(n) time. From lemma 3, it only remains to enumerate all possible ways of merging the SPT-order lists of jobs of £ O and £ N . Algorithm MS does so by comparing the cost of all possible state transitions to find an optimal schedule, while the recurrence relation requires constant time for each set of the values of the state variables. Thus, the overall time complexity of Algorithm MS is O(n + n N log n N ). Now, we focus on problem 1|p jr = p j r α , ∆ j (π * ) ≤ k| C j . We know that the problem can be deduced to 1| ∆ j (π * ) ≤ k| C j when α = 0, and which is proved to be binary NP-hard (Hall and Potts, 2004). Therefore, problem 1|p jr = p j r α , ∆ j (π * ) ≤ k| C j is at least binary NP-hard. Lemma 1 and lemma 4 show that local optimal partial schedule can be found by merging several appropriate jobs of £ O and £ N by SPT-order, respectively. For such problem, an optimal merging can be performed subject to the given constraint on the total sequence disruptions by the following dynamic programming algorithm.
Obviously, for the recurrence relation in Step 5, the term corresponds to the case where the partial schedule ends with job J i ∈ £ O , and j jobs of £ N appear before job J i in such a partial schedule. The increase in the total sequence disruption is equal to j. The term f (i, j − 1, τ ) corresponds to the case where the partial schedule ends with job J n O +j ∈ £ N . The total sequence disruption is still equal to j. Thus, we have Proposition 5. An optimal schedule for problem 1|p jr = p j r α , For problem 1|p jr = p j r α , ∆ j (π * ) ≤ k|C max , we only modify the recurrence relation of the above algorithm into f (i, j, δ) Similarly, we have the following proposition. Proposition 6. An optimal schedule for problem 1|p jr = p j r α , ∆ j (π * ) ≤ k|C max can be found in O(n O n N min{n O P N , n N P O }).

4.
Rescheduling objective and disruption cost problem. In this section, we consider rescheduling problems to minimize the sum of several classical objectives and the costs of position disruption caused by inserting new jobs. For such problems, we try to find an appropriate partial sequence to insert the original job sequence so as to minimize the objectives. That is, if there exist n N new jobs to be inserted to the original job sequence, the position disruption reaches up to n N times at most, Thus, according to the definition of D max , we use the approach which has solved problem 1|p jr = p j r α , D max (π * ) ≤ k|C max (k = 0, 1, 2, ..., n N ) to study problem 1|p jr = p j r α |C max + µD max (π * ). Let σ k denote an optimal schedule and compute min 0≤k≤n N {C max (σ k ) + µk}, we propose the following algorithm.

Algorithm II
Step 1. Index the jobs of £ N in SPT-order, i.e.
Step 2. If job p n O ≤ p n O +1 , then terminate; otherwise, define j such that number n O + j is the index of the last job of J N sequenced before job J n O .
Step 2.1 Let r j be the processed position of job J n O +j , and x j be the number of those jobs which sequenced after jobs J n O +j up to and including J n O .
Step 2.2 Set σ j to be the schedule defined by the current job sequence, and compute C max (σ j ).
Step 3.1 Form schedule σ j−1 from σ j by moving job J n O +k immediately after job J n O .
Proposition 7. For problem 1|p jr = p j r α |C max + µD max (π * ), an optimal schedule can be found Algorithm II in O(n + n N log n N ).
Proof. Algorithm II computes min where σ k is found by solving problem 1|p jr = p j r α , D max (π * ) ≤ k|C max , and it generates an optimal schedule since all the possible values of k are considered.
Step 1 requires O(n N log n N ) time to construct a SPT schedule of all jobs of £ N , and O(n) time to construct a SPT schedule of all jobs, while Step 2 requires O(n) time.
Step 3 performs at most j times sine j ≤ n N , and each application requires constant time. Therefore, the computational complexity of Algorithm II is O(n + n N log n N ).
The following numerical example will illustrate the working principle of the above algorithm. Obviously, if all the jobs are rescheduled by SPT rule, the objective value is 53.4803. By using above algorithm, there exist a finite number of new jobs (such as j = 4) to be inserted to the original sequence to construct a new sequence, i.e. σ j = (J 1 , J a , J 2 , J 3 , J b , J c , J 4 , J 5 , J d , J 6 , J e , J f ), and according to Step 3.1, we have σ j−1 = (J 1 , J a , J 2 , J 3 , J b , J c , J 4 , J 5 , J 6 , J d , J e , J f ). Thus, we have r j = 9, x j = 1 and obtain A j = (p n O , p n O +4 ) = (p n O , p d ), B j = (r α j , (r j +x j ) α ) = (9 α , 10 α ). Therefore, C max (σ j ) = C max (σ j−1 ) + (p n O , p d )H 2 (9 α , 10 α ) T . Repeating such computation, we have the optimal sequence from such k sequences and the optimal cost is 51.032.
Secondly, we consider problem 1|p jr = p j r α | C j + µD max (π * ). For such problem, we propose the following algorithm.

Algorithm III
Step 1. Index the jobs of £ N in SPT order.
Step 2. If job p n O ≤ p n O +1 , then terminate; otherwise, define j such that n O + j is the index of the last job of J N that is sequenced before job J n O .
Step 2.1 Let r j be the processed position of job J n O +j , and x j be the number of those jobs which are sequenced after jobs J n O +j up to and including J n O . Step Step 2.3 Set σ j to be the schedule defined by the current job sequence, and compute h∈£ C h (σ j ).
Step 3.1 Form schedule σ k−1 from σ k by moving job J n O +k immediately after job J n O .
Step 3.2 Compute Step 4. Find the optimal schedule σ * = σ k * such that k * = arg min Proposition 8. For problem 1|p jr = p j r α | C j +µD max (π * ), an optimal schedule can be found by Algorithm III in O(n + n N log n N ).
Proof. The proof is similar to that of Proposition 4. If all the jobs are rescheduled by SPT rule, the objective value is 225.4965. Similar to do the procedure in example 1 and using above algorithm, we can obtain the optimal schedule by sequencing the jobs in the order as and the optimal cost is 223.5387.

Algorithm IV
Step 1. Index the jobs of £ N in SPT order.
Step 2. If job p n O ≤ p n O +1 , then terminate; otherwise, define j such that n O + j is the index of the last job of J N that is sequenced before job J n O .
Step 2.1 Let r j be the processed position of job J n O +j , and x j be the number of those jobs which are sequenced after jobs J n O +j up to and including J n O .
Step 2.2 Set σ j to be the schedule defined by the current job sequence, and compute C n O (σ j ) and C max (σ j ).
Step 3.1 Form schedule σ j−1 from σ j by moving job J n O +k immediately after job J n O . Step Step 4. Find schedule σ k * such that k * = arg min Proposition 9. For problem 1|p jr = p j r α |C max + µ∆ max (π * ), an optimal schedule can be found by Algorithm IV in O(n + n N log n N ).
Proof. The process of proof is similar to that of Proposition 4. If all the jobs are rescheduled by SPT rule, the objective value is 47.0544. Similar to do the procedure in example 1 and using above algorithm, we can obtain the optimal schedule by sequencing the jobs in the order as and the optimal cost is 45.5074.

Algorithm V
Step 1. Index the jobs of £ N in SPT order.
Step 2. If job p n O ≤ p n O +1 , then terminate; otherwise, define j such that n O + j is the index of the last job of J N that is sequenced before job J n O .
Step 2.1 Let r j be the processed position of job J n O +j , and x j be the number of those jobs which are sequenced after jobs J n O +j up to and including J n O .
Step 2.2 Set σ j to be the schedule defined by the current job sequence, and compute C n O (σ j ) and C max (σ j ).
Step 3.1 Form schedule σ j−1 from σ j by moving job J n O +k immediately after job J n O .
Proposition 10. For problem 1|p jr = p j r α | C j + µ∆ max (π * ), an optimal schedule can be found by Algorithm V in O(n + n N log n N ).
Proof. The process of proof is similar to that of Proposition 4. If all the jobs are rescheduled by SPT rule, the objective value is 216.5706. Similar to do the procedure in example 1 and using above algorithm, we can obtain the optimal schedule by sequencing the jobs in the order as J 1 ≺ J a ≺ J 2 ≺ J b ≺ J c ≺ J d ≺ J 3 ≺ J 4 ≺ J 5 ≺ J e ≺ J f ≺ J g , and the optimal cost is 216.1061.

5.
Conclusions. In this paper, we consider single-machine rescheduling problems with learning effect under disruption constraints. In the proposed scheduling models, learning effect means that the workers gain experience from producing jobs and make the actual processing time of jobs shorter than their normal processing time, while rescheduling means to schedule the sequenced jobs again together with a set of new arrived jobs so as to generate a new feasible schedule and create disruptions. The goal of optimizing system performance is addressed by minimizing the makespan or the total completion time of the new jobs being integrated into the schedule under the limited disruption constraints, respectively. For the considered problems, by using several proposed lemmas and classical scheduling rules, we provide polynomial-time algorithms of minimizing the makespan and the total completion time problems under several disruption constraints between the original and revised schedules, respectively. For some models, we also designed dynamic programming algorithms to analyze them. However, in this paper, we only study single-machine rescheduling problems with learning effect consideration for the determinate new arrival jobs, therefore, we will extend the models to dynamic new job arrivals and multiple machines in the future.