Next Article in Journal
Automated Processing of fNIRS Data—A Visual Guide to the Pitfalls and Consequences
Next Article in Special Issue
Hybrid Flow Shop with Unrelated Machines, Setup Time, and Work in Progress Buffers for Bi-Objective Optimization of Tortilla Manufacturing
Previous Article in Journal
Control Strategy of Speed Servo Systems Based on Deep Reinforcement Learning
Previous Article in Special Issue
Optimal Control Algorithms and Their Analysis for Short-Term Scheduling in Manufacturing Systems

Algorithms 2018, 11(5), 66; https://doi.org/10.3390/a11050066

Article
Single Machine Scheduling Problem with Interval Processing Times and Total Completion Time Objective
United Institute of Informatics Problems, National Academy of Sciences of Belarus, Surganova Street 6, Minsk 220012, Belarus
*
Author to whom correspondence should be addressed.
Received: 2 March 2018 / Accepted: 23 April 2018 / Published: 7 May 2018

Abstract

:
We consider a single machine scheduling problem with uncertain durations of the given jobs. The objective function is minimizing the sum of the job completion times. We apply the stability approach to the considered uncertain scheduling problem using a relative perimeter of the optimality box as a stability measure of the optimal job permutation. We investigated properties of the optimality box and developed algorithms for constructing job permutations that have the largest relative perimeters of the optimality box. Computational results for constructing such permutations showed that they provided the average error less than 0 . 74 % for the solved uncertain problems.
Keywords:
scheduling; uncertain durations; single machine; total completion time

1. Introduction

Since real-life scheduling problems involve different forms of uncertainties, several approaches have been developed in the literature for dealing with uncertain scheduling problems. In a stochastic approach, job processing times are assumed to be random variables with the known probability distributions [1,2]. If one has no sufficient information to characterize the probability distribution of all random processing times, other approaches are needed [3,4,5]. In the approach of seeking a robust schedule [3,6], the decision-maker prefers a schedule that hedges against the worst-case scenario. A fuzzy approach [7,8,9] allows a scheduler to determine best schedules with respect to fuzzy processing times. A stability approach [10,11,12] is based on the stability analysis of the optimal schedules to possible variations of the numerical parameters. In this paper, we apply the stability approach to a single machine scheduling problem with uncertain processing times of the given jobs. In Section 2, we present the setting of the problem and the related results. In Section 3, we investigate properties of an optimality box of the permutation used for processing the given jobs. Efficient algorithms are derived for finding a job permutation with the largest relative perimeter of the optimality box. In Section 5, we develop an algorithm for finding an approximate solution for the uncertain scheduling problem. In Section 6, we report on the computational results for finding the approximate solutions for the tested instances. Section 7 includes the concluding remarks.

2. Problem Setting and the Related Results

There are given n jobs J = { J 1 , J 2 , . . . , J n } to be processed on a single machine. The processing time p i of the job J i J can take any real value from the given segment [ p i L , p i U ] , where p i U p i L > 0 . The exact value p i [ p i L , p i U ] of the job processing time remains unknown until completing the job J i J . Let R + n denote a set of all non-negative n-dimensional real vectors. The set of all possible vectors ( p 1 , p 2 , , p n ) = p R + n of the job processing times is presented as the Cartesian product of the segments [ p i L , p i U ] : T = { p R + n : p i L p i p i U , i { 1 , 2 , , n } } = [ p 1 L , p 1 U ] × [ p 2 L , p 2 U ] × × [ p n L , p n U ] = : × i = 1 n [ p i L , p i U ] . Each vector p T is called a scenario.
Let S = { π 1 , π 2 , , π n ! } be a set of all permutations π k = ( J k 1 , J k 2 , , J k n ) of the jobs J . Given a scenario p T and a permutation π k S , let C i = C i ( π k , p ) denote the completion time of the job J i J in the schedule determined by the permutation π k . The criterion C i denotes the minimization of the sum of job completion times: J i J C i ( π t , p ) = min π k S J i J C i ( π k , p ) , where the permutation π t = ( J t 1 , J t 2 , , J t n ) S is optimal for the criterion C i . This problem is denoted as 1 | p i L p i p i U | C i using the three-field notation α | β | γ [13], where γ denotes the objective function. If scenario p T is fixed before scheduling, i.e., [ p i L , p i U ] = [ p i , p i ] for each job J i J , then the uncertain problem 1 | p i L p i p i U | C i is turned into the deterministic one 1 | | C i . We use the notation 1 | p | C i to indicate an instance of the problem 1 | | C i with the fixed scenario p T . Any instance 1 | p | C i is solvable in O ( n log n ) time [14] since the following claim has been proven.
Theorem 1.
The job permutation π k = ( J k 1 , J k 2 , , J k n ) S is optimal for the instance 1 | p | C i if and only if the following inequalities hold: p k 1 p k 2 p k n . If p k u < p k v , then job J k u precedes job J k v in any optimal permutation π k .
Since a scenario p T is not fixed for the uncertain problem 1 | p i L p i p i U | C i , the completion time C i of the job J i J cannot be exactly determined for the permutation π k S before the completion of the job J i . Therefore, the value of the objective function C i for the permutation π k remains uncertain until jobs J have been completed.
Definition 1.
Job J v dominates job J w (with respect to T) if there is no optimal permutation π k S for the instance 1 | p | C i , p T , such that job J w precedes job J v .
The following criterion for the domination was proven in [15].
Theorem 2.
Job J v dominates job J w if and only if p v U < p w L .
Since for the problem α | p i L p i p i U | γ , there does not usually exist a permutation of the jobs J being optimal for all scenarios T, additional objectives or agreements are often used in the literature. In particular, a robust schedule minimizing the worst-case regret to hedge against data uncertainty has been developed in [3,8,16,17,18,19,20]. For any permutation π k S and any scenario p T , the difference γ p k - γ p t = : r ( π k , p ) is called the regret for permutation π k with the objective function γ equal to γ p k under scenario p. The value Z ( π k ) = max { r ( π k , p ) : p T } is called the worst-case absolute regret. The value Z * ( π k ) = max { r ( π k , p ) γ p t : p T } is called the worst-case relative regret. While the deterministic problem 1 | | C i is polynomially solvable [14], finding a permutation π t S minimizing the worst-case absolute regret Z ( π k ) or the relative regret Z * ( π k ) for the problem 1 | p i L p i p i U | C i are binary NP-hard even for two scenarios [19,21]. In [6], a branch-and-bound algorithm was developed to find a permutation π k minimizing the absolute regret for the problem 1 | p i L p i p i U | w i C i , where jobs J i J have weights w i > 0 . The computational experiments showed that the developed algorithm is able to find such a permutation π k for the instances with up to 40 jobs. The fuzzy scheduling technique was used in [7,8,9,22] to develop a fuzzy analogue of dispatching rules or to solve mathematical programming problems to determine a schedule that minimizes a fuzzy-valued objective function.
In [23], several heuristics were developed for the problem 1 | p i L p i p i U | w i C i . The computational experiments including different probability distributions of the processing times showed that the error of the best performing heuristic was about 1 % of the optimal objective function value w i C i obtained after completing the jobs when their factual processing times became known.
The stability approach [5,11,12] was applied to the problem 1 | p i L p i p i U | w i C i in [15], where hard instances were generated and solved by the developed Algorithm MAX-OPTBOX with the average error equal to 1 . 516783 % . Algorithm MAX-OPTBOX constructs a job permutation with the optimality box having the largest perimeter.
In Section 3, Section 4, Section 5 and Section 6, we continue the investigation of the optimality box for the problem 1 | p i L p i p i U | C i . The proven properties of the optimality box allows us to develop Algorithm 2 for constructing a job permutation with the optimality box having the largest relative perimeter and Algorithm 3, which outperforms Algorithm MAX-OPTBOX for solving hard instances of the problem 1 | p i L p i p i U | C i . Algorithm 3 constructs a job permutation π k , whose optimality box provides the minimal value of the error function introduced in Section 5. Randomly generated instances of the problem 1 | p i L p i p i U | C i were solved by Algorithm 3 with the average error equal to 0 . 735154 % .

3. The Optimality Box

Let M denote a subset of the set N = { 1 , 2 , , n } . We define an optimality box for the job permutation π k S for the problem 1 | p i L p i p i U | C i as follows.
Definition 2.
The maximal (with respect to the inclusion) rectangular box OB ( π k , T ) = × k i M [ l k i * , u k i * ] T is called the optimality box for the permutation π k = ( J k 1 , J k 2 , , J k n ) S with respect to T , if the permutation π k being optimal for the instance 1 | p | C i with the scenario p = ( p 1 , p 2 , , p n ) T remains optimal for the instance 1 | p | C i with any scenario p OB ( π k , T ) × { × k j N \ M [ p k j , p k j ] } . If there does not exist a scenario p T such that the permutation π k is optimal for the instance 1 | p | C i , then OB ( π k , T ) = .
Any variation p k i of the processing time p k i , J k i J , within the maximal segment [ l k i * , u k i * ] indicated in Definition 2 cannot violate the optimality of the permutation π k S provided that the inclusion p k i [ l k i * , u k i * ] holds. The non-empty maximal segment [ l k i * , u k i * ] with the inequality l k i * u k i * and the length u k i * - l k i * 0 indicated in Definition 2 is called an optimality segment for the job J k i J in the permutation π k . If the maximal segment [ l k i * , u k i * ] is empty for job J k i J , we say that job J k i has no optimality segment in the permutation π k . It is clear that if job J k i has no optimality segment in the permutation π k , then the inequality l k i * > u k i * holds.

3.1. An Example of the Problem 1 | p i L p i p i U | C i

Following to [15], the notion of a block for the jobs J may be introduced for the problem 1 | p i L p i p i U | C i as follows.
Definition 3.
A maximal set B r = { J r 1 , J r 2 , , J r | B r | } J of the jobs, for which the inequality max J r i B r p r i L min J r i B r p r i U holds, is called ablock. The segment [ b r L , b r U ] with b r L = max J r i B r p r i L and b r U = min J r i B r p r i U is called acoreof the block B r .
If job J i J belongs to only one block, we say that job J i is fixed (in this block). If job J k J belongs to two or more blocks, we say that job J k is non-fixed. We say that the block B v is virtual, if there is no fixed job in the block B v .
Remark 1.
Any permutation π k S determines a distribution of all non-fixed jobs to their blocks. Due to the fixings of the positions of the non-fixed jobs, some virtual blocks may be destroyed for the permutation π k . Furthermore, the cores of some non-virtual blocks may be increased in the permutation π k .
We demonstrate the above notions on a small example with input data given in Table 1. The segments [ p i L , p i U ] of the job processing times are presented in a coordinate system in Figure 1, where the abscissa axis is used for indicating the segments given for the job processing times and the ordinate axis for the jobs from the set J . The cores of the blocks B 1 , B 2 , B 3 and B 4 are dashed in Figure 1.
There are four blocks in this example as follows: { B 1 , B 2 , B 3 , B 4 } = : B . The jobs J 1 , J 2 , J 3 , J 4 and J 5 belong to the block B 1 . The jobs J 4 , J 5 and J 7 are non-fixed. The remaining jobs J 1 , J 2 , J 3 , J 6 , J 8 , J 9 and J 10 are fixed in their blocks. The block B 2 is virtual. The jobs J 4 , J 5 and J 7 belong to the virtual block B 2 . The jobs J 4 , J 6 , and J 7 belong to the block B 3 . The jobs J 7 , J 8 , J 9 and J 10 belong to the block B 4 .

3.2. Properties of a Job Permutation Based on Blocks

The proof of Lemma 1 is based on Procedure 1.
Lemma 1.
For the problem 1 | p i L p i p i U | C i , the set B = { B 1 , B 2 , , B m } of all blocks can be determined in O ( n log n ) time.
Proof. 
The right bound b 1 U of the core of the first block B 1 B is determined as follows: b 1 U = min J i J p i U . Then, all jobs included in the block B 1 may be determined as follows: B 1 = { J i J : p i L b 1 U p i U } . The left bound b 1 L of the core of the block B 1 is determined as follows: b 1 L = max J i B 1 p i L . Then, one can determine the second block B 2 B via applying the above procedure to the subset of set J without jobs J i , for which the equality b 1 U = p i U holds. This process is continued until determining the last block B m B . Thus, one can use the above procedure (we call it Procedure 1) for constructing the set B = { B 1 , B 2 , , B m } of all blocks for the problem 1 | p i L p i p i U | C i . Obviously, Procedure 1 has the complexity O ( n log n ) . ☐
Any block from the set B has the following useful property.
Lemma 2.
At most two jobs in the block B r B may have the non-empty optimality segments in any fixed permutation π k S .
Proof. 
Due to Definition 3, the inclusion [ b r L , b r U ] [ p i L , p i U ] holds for each job J i B r . Thus, due to Definition 2, only job J k i , which is the first one in the permutation π k among the jobs from the block B r , and only job J k v B r , which is the last one in the permutation π k among the jobs from the block B r , may have the non-empty optimality segments. It is clear that these non-empty segments look as follows: [ p k i L , u k i * ] and [ l k v * , p k v U ] , where u k i * b r L and b r U l k v * . ☐
Lemma 3.
If OB ( π k , T ) , then any two jobs J v B r and J w B s , which are fixed in different blocks, r < s , must be ordered in the permutation π k S with the increasing of the left bounds (and the right bounds as well) of the cores of their blocks, i.e., the permutation π k looks as follows: π k = ( , J v , , J w , ) , where b r L < b s L .
Proof. 
For any two jobs J v B r and J w B s , r < s , the condition [ p v L , p v U ] [ p w L , p w U ] = holds. Therefore, the same permutation π k = ( , J v , , J w , ) is obtained if jobs J v B r and J w B s are ordered either in the increasing of the left bounds of the cores of their blocks or in the increasing of the right bounds of the cores of their blocks. We prove Lemma 3 by a contradiction. Let the condition OB ( π k , T ) hold. However, we assume that there are fixed jobs J v B r and J w B s , r < s , which are located in the permutation π k S in the decreasing order of the left bounds of the cores of their blocks B r and B s . Note that blocks B r and B s cannot be virtual.
Due to our assumption, the permutation π k looks as follows: π k = ( , J w , , J v , ) , where b r L < b s L . Using Definition 3, one can convince that the cores of any two blocks have no common point. Thus, the inequality b r L < b s L implies the inequality b r U < b s L . The inequalities p v L p v b r U < b s L p w L p w hold for any feasible processing time p v and any feasible processing time p w , where p T . Hence, the inequality p v < p w holds as well, and due to Theorem 1, the permutation π k S cannot be optimal for any fixed scenario p T . Thus, the equality OB ( π k , T ) = holds due to Definition 2. This contradiction with our assumption completes the proof. ☐
Next, we assume that blocks in the set B = { B 1 , B 2 , , B m } are numbered according to the increasing of the left bounds of their cores, i.e., the inequality b v L < b u L implies v < u . Due to Definition 3, each block B r = { J r 1 , J r 2 , , J r | B r | } may include jobs of the following four types. If p r i L = b r L and p r i U = b r U , we say that job J r i is a core job in the block B r . Let B r * be a set of all core jobs in the block B r . If p r i L < b r L , we say that job J r i is a left job in the block B r . If p r i U > b r U , we say that job J r i is a right job in the block B r . Let B r - ( B r + ) be a set of all left (right) jobs in the block B r . Note that some job J r i B r may be left-right job in the block B r , since it is possible that B \ { B r * B r - B r + } .
Two jobs J v and J w are identical if both equalities p v L = p w L and p v U = p w U hold. Obviously, if the set B r B is a singleton, | B r | = 1 , then the equality B r = B r * holds. Furthermore, the latter equality cannot hold for a virtual block B t B since any trivial block must contain at least two non-fixed jobs.
Theorem 3.
For the problem 1 | p i L p i p i U | C i , any permutation π k S has an empty optimality box OB ( π k , T ) = , if and only if for each block B r B , either condition | B r | = | B r * | 2 holds or B r = B r - B r + , all jobs in the set B r - (in the set B r + ) are identical and the following inequalities hold: | B r - | 2 and | B r + | 2 .
Proof. 
Sufficiency. It is easy to prove that there is no virtual block in the considered set B. First, we assume that for each block B r B , the condition | B r | = | B r * | 2 holds.
Due to Lemma 3, in the permutation π k S with the non-empty optimality box OB ( π k , T ) , all jobs must be located in the increasing order of the left bounds of the cores of their blocks. However, in the permutation π k S , the following two equalities hold for each block B r B : min J i B r p i U = max J i B r p i U and max J i B r p i L = min J i B r p i L . Since | B r | 2 , there is no job J v B r , which has an optimality segment in any fixed permutation π k S due to Lemma 2. Hence, the equality OB ( π k , T ) = must hold, if the condition | B r | = | B r * | 2 holds for each block B r B .
We assume that there exists a block B r B such that all jobs are identical in the set B r - with | B r - | 2 and all jobs are identical in the set B r + with | B r + | 2 . Thus, for the permutation π k S , the equalities min J i B r - p i U = max J i B r - p i U and max J i B r - p i L = min J i B r - p i L hold. Since | B r - | 2 and all jobs are identical in the set B r - , there is no job J v B r - , which has the optimality segment in any fixed permutation π k S .
Similarly, one can prove that there is no job J v B r + , which has the optimality segment in any fixed permutation π k S . Thus, we conclude that if the condition of Theorem 3 holds for each block B r B , then each job J i J has no optimality segment in any fixed permutation π k S . Thus, if the condition of Theorem 3 holds, the equality OB ( π k , T ) = holds for any permutation π k S .
Necessity. We prove the necessity by a contradiction. We assume that any permutation π k S has an empty optimality box OB ( π k , T ) = . Let the condition | B r | = | B r * | 2 do not hold. If | B r | = | B r * | = 1 , the set B r is a singleton and so job J r 1 B r has the optimality segment [ p r 1 L , p r 1 U ] with the length p r 1 U - p r 1 L 0 in the permutation π k * S , where all jobs are ordered according to the increasing of the left bounds of the cores of their blocks. Let the following condition hold:
| B r | > | B r * | 2 .
The condition (1) implies that there exists at least one left job or right job or left-right job J r i B r . If job J r i is a left job or a left-right job (a right job) in the block B r , then job J r i must be located on the first place (on the last place, respectively) in the above permutation π k * S among all jobs from the block B r . All jobs from the set B r \ { B r * { J r i } } must be located between job J r v B r * and job J r w B r * . Therefore, the left job J r i or the left-right job J r i (the right job J r i ) has the following optimality segment [ p r i L , b r L ] (segment [ b r U , p r i U ] , respectively) with the length b r L - p r i L > 0 (the length p r i U - b r U > 0 , respectively) in the permutation π k * . Let the equality B r = B r - B r + do not hold. If there exist a job J r i B r * , this job must be located between the jobs J r v B r - and J r w B r - . It is clear that the job J r i has the optimality segment [ b r L , b r U ] with the length b r U - b r L > 0 in the permutation π k * .
Let the following conditions hold: B r = B r - B r + , | B r - | 2 , | B r + | 2 . However, we assume that jobs from the set B r - are not identical. Then the job J r u B r - with the largest segment [ p r u L , p r u U ] among the jobs from the set B r - must be located in the permutation π k * before other jobs from the set B r - . It is clear that the job J r u has the optimality segment in the permutation π k * .
Similarly, we can construct the permutation π k * with the non-empty optimality box, if the jobs from the set B r + are not identical.
Let the equality B r = B r - B r + hold. Let all jobs in the set B r - (and all jobs in the set B r + ) be identical. However, we assume that the equality | B r - | = 1 holds. The job J r i B r - has the optimality segment in the permutation π k * , if the job J r i is located before other jobs in the set B r .
Similarly, one can construct the permutation π k * such that job J r i B r + has the optimality segment in the permutation π k * , if the inequality | B r + | 2 is violated. Thus, we conclude that in all cases of the violating of the condition of Theorem 3, we can construct the permutation π k * S with the non-empty optimality box OB ( π k * , T ) . This conclusion contradicts to our assumption that any permutation π k S has an empty optimality box OB ( π k , T ) = . ☐
Next, we present Algorithm 1 for constructing the optimality box OB ( π k , T ) for the fixed permutation π k S . In steps 1–4 of Algorithm 1, the problem 1 | p ^ i L p i p ^ i U | C i with the reduced segments of the job processing times is constructed. It is clear that the optimality box for the permutation π k S for the problem 1 | p i L p i p i U | C i coincides with the optimality box for the same permutation for the problem 1 | p ^ i L p i p ^ i U | C i , where given segments of the job processing times are reduced. In steps 5 and 6, the optimality box for the permutation π k for the problem 1 | p ^ i L p i p ^ i U | C i is constructed. It takes O ( n ) time for constructing the optimality box OB ( π k , T ) for any fixed permutation π k S using Algorithm 1.
Algorithm 1
Input: Segments [ p i L , p i U ] for the jobs J i J . The permutation π k = ( J k 1 , J k 2 , , J k n ) .
Output: The optimality box OB ( π k , T ) for the permutation π k S .
    Step 1: FOR i = 1 to n DO set p ^ i L = p i L , p ^ i U = p i U END FOR
                 set t L = p ^ 1 L , t U = p ^ n U
     Step 2: FOR i = 2 to n DO
                  IF p ^ i L < t L THEN set p ^ i L = t L ELSE set t L = p ^ i L END FOR
    Step 3: FOR i = n - 1 to 1 STEP - 1 DO
                  IF p ^ i U > t U THEN set p ^ i U = t U ELSE set t U = p ^ i U END FOR
    Step 4: Set p ^ 0 U = p ^ 1 L , p ^ n + 1 L = p ^ n U .
    Step 5: FOR i = 1 to n DO set d ^ k i - = max p ^ k i L , p ^ k i - 1 U , d ^ k i + = min p ^ k i U , p ^ k i + 1 L
                 END FOR
    Step 6: Set OB ( π k , T ) = × d ^ i - d ^ i + d ^ k i - , d ^ k i + STOP.

3.3. The Largest Relative Perimeter of the Optimality Box

If the permutation π k S has the non-empty optimality box OB ( π k , T ) , then one can calculate the length of the relative perimeter of this box as follows:
P e r OB ( π k , T ) = J k i J ( π k ) u k i * - l k i * p k i U - p k i L ,
where J ( π k ) denotes the set of all jobs J i J having optimality segments [ l k i * , u k i * ] with the positive lengths, l k i * < u k i * , in the permutation π k . It is clear that the inequality l k i * < u k i * may hold only if the inequality p k i L < p k i U holds. Theorem 3 gives the sufficient and necessary condition for the smallest value of P e r OB ( π k , T ) , i.e., the equalities J ( π k ) = and P e r OB ( π k , T ) = 0 hold for each permutation π k S . A necessary and sufficient condition for the largest value of P e r OB ( π k , T ) = n is given in Theorem 4. The sufficiency proof of Theorem 4 is based on Procedure 2.
Theorem 4.
For the problem 1 | p i L p i p i U | C i , there exists a permutation π k S , for which the equality P e r OB ( π k , T ) = n holds, if and only if for each block B r B , either | B r | = | B r * | = 1 or B r = B r - B r + with | B r | = 2 .
Proof. 
Sufficiency. Let the equalities | B r | = | B r * | = 1 hold for each block B r B . Therefore, both equalities B r = B r * and | B | = n hold. Due to Theorem 2 and Lemma 3, all jobs must be ordered with the increasing of the left bounds of the cores of their blocks in each permutation π k S such that OB ( π k , T ) . Each job J k i J in the permutation π k = ( J k 1 , J k 2 , , J k n ) has the optimality segments [ l k i * , u k i * ] with the maximal possible length
u k i * - l k i * = p k i U - p k i L .
Hence, the desired equalities
P e r OB ( π k , T ) = J k i J ( π k ) p k i U - p k i L p k i U - p k i L = n
hold, if the equalities | B r | = | B r * | = 1 hold for each block B r B .
Let there exist a block B r B such that the equalities B r = B r - B r + and | B r | = 2 hold. It is clear that the equalities | B r - | = | B r + | = 1 hold as well, and job J k i from the set B r - (from the set B r + ) in the permutation π k has the optimality segments [ l k i * , u k i * ] with the maximal possible length determined in (3). Hence, the equalities (4) hold, if there exist blocks B r B with the equalities B r = B r - B r + and | B r | = 2 . This sufficiency proof contains the description of Procedure 2 with the complexity O ( n ) .
Necessary. If there exists at least one block B r B such that neither condition | B r | = | B r * | = 1 nor condition B r = B r - B r + , | B r | = 2 hold, then the equality (3) is not possible for at least one job J k i B r . Therefore, the inequality P e r OB ( π k , T ) < n holds for any permutation π k S . ☐
The length of the relative perimeter P e r OB ( π k , T ) may be used as a stability measure for the optimal permutation π k . If the permutation π k S has the non-empty optimality box OB ( π k , T ) with a larger length of the relative perimeter than the optimality box OB ( π t , T ) has, π k π t S , then the permutation π k S may provide a smaller value of the objective function C i than the permutation π t . One can expect that the inequality J i J C i ( π k , p ) J i J C i ( π t , p ) holds for more scenarios p from the set T than the opposite inequality J i J C i ( π k , p ) > J i J C i ( π t , p ) . Next, we show how to construct a permutation π k S with the largest value of the relative perimeter P e r OB ( π k , T ) . The proof of Theorem 4 is based on Procedure 3.
Theorem 5.
If the equality B 1 = J holds, then it takes O ( n ) time to find the permutation π k S and the optimality box OB ( π k , T ) with the largest length of the relative perimeter P e r OB ( π k , T ) among all permutations S.
Proof. 
Since the equality B 1 = J holds, each permutation π k S looks as follows: π k = ( J k 1 , J k 2 , , J k n ) , where { J k 1 , J k 2 , , J k n } = B 1 . Due to Lemma 2, only job J k 1 may have the optimality segment (this segment looks as follows: [ p k 1 L , u k 1 * ] ) and only job J n may have the following optimality segment [ l k n * , p k n U ] . The length u k 1 * - p k 1 L of the optimality segment [ p k 1 L , u k 1 * ] for the job J k 1 is determined by the second job J k 2 in the permutation π k . Similarly, the length p k n U - l k n * of the optimality segment [ l k n * , p k n U ] for the job J k n is determined by the second-to-last job J k n - 1 in the permutation π k . Hence, to find the optimality box OB ( π k , T ) with the largest value of P e r OB ( π k , T ) , it is needed to test only four jobs J k 1 , J k 2 , J k n - 1 and J k n from the block B 1 = J , which provide the largest relative optimality segments for the jobs J k 1 and J k n .
To this end, we should choose the job J k i such that the following equality holds: p k i L = min J k s B 1 b 1 U - p k s L p k s U - p k s L . Then, if B 1 \ { J k i } , we should choose the job J k v such that the equality p k v U = max J k s B 1 \ { J k i } p k s U - b 1 L p k s U - p k s L holds. Then, if B 1 \ { J k i , J k v } , we should choose the job J k i + 1 such that the equality p k i + 1 L = min J k s B 1 \ { J k i , J k v } p k s L holds. Then, if B 1 \ { J k i , J k i + 1 , J k v } , we should choose the job J k v - 1 such that the equality p k v - 1 U = max J k s B 1 \ { J k i , J k i + 1 , J k v } p k s U holds. Thus, to determine the largest value of P e r OB ( π k , T ) , one has either to test a single job or to test two jobs or three jobs or to choose and test four jobs from the block B 1 , where | B 1 | 4 , independently of how large the cardinality | B 1 | of the set B 1 is. In the worst case, one has to test at most 4 ! = 24 permutations of the jobs chosen from the set B 1 . Due to the direct testing of the chosen jobs, one selects a permutation of | B 1 | jobs, which provides the largest length of the relative perimeter P e r OB ( π k , T ) for all | B 1 | ! permutations π k . If B 1 = J , the above algorithm (we call it Procedure 3) for finding the permutation π k with the largest value of P e r OB ( π k , T ) takes O ( n ) time. Theorem 5 has been proven. ☐
Remark 2.
If J i B r B , then the job J i must be located either on the left side from the core of the block B r or on the right side from this core in any permutation π k having the largest relative perimeter of the optimality box OB ( π k , T ) . Hence, job J i must precede (or succeed, respectively) each job J v B k . The permutation π t of the jobs from the block B r obtained using Procedure 3 described in the proof of Theorem 5, where jobs B r are sequenced, remains the same if job J i B r B is added to the permutation π t .
Lemma 4.
Let there exist two adjacent blocks B r B and B r + 1 B , such that the equality B r B r + 1 = holds. Then the problem 1 | p i L p i p i U | C i can be decomposed into the subproblem P 1 with the set of jobs J 1 : = k = 1 r B k and the subproblem P 2 with the set of jobs J 2 : = k = r + 1 m B k = J \ J 1 . The optimality box OB ( π k , T ) with the largest length of the relative perimeter may be obtained as the Cartesian product of the optimality boxes constructed for the subproblems P 1 and P 2 .
Proof. 
Since the blocks B r and B r + 1 have no common jobs, the inequality p u U < p v L holds for each pair of jobs J u k = 1 r B k and J v k = r + 1 m B k . Due to Theorem 2, any job J u k = 1 r B k dominates any job J v k = r + 1 m B k . Thus, due to Definition 1, there is no optimal permutation π k S for the instance 1 | p | C i with a scenario p T such that job J v precedes job J u in the permutation π k . Due to Definition 2, a non-empty optimality box OB ( π k , T ) is possible only if job J u is located before job J v in the permutation π r . The optimality box OB ( π k , T ) with the largest relative perimeter for the problem 1 | p i L p i p i U | C i may be obtained as the Cartesian product of the optimality boxes with the largest length of the relative perimeters constructed for the subproblems P 1 and P 2 , where the set of jobs k = 1 r B k and the set of jobs k = r + 1 m B k are considered separately one from another. ☐
Let B * denote a subset of all blocks of the set B, which contain only fixed jobs. Let J * denote a set of all non-fixed jobs in the set J . Let the set B ( J u ) B * denote a set of all blocks containing the non-fixed job J u J * . Theorem 5, Lemma 6 and the constructive proof of the following claim allows us to develop an O ( n log n ) -algorithm for constructing the permutation π k with the largest value of P e r OB ( π k , T ) for the special case of the problem 1 | p i L p i p i U | C i . The proof of Theorem 6 is based on Procedure 4.
Theorem 6.
Let each block B r B contain at most one non-fixed job. The permutation π k S with the largest value of the relative perimeter P e r OB ( π k , T ) is constructed in O ( n log n ) time.
Proof. 
There is no virtual block in the set B, since any virtual block contains at least two non-fixed jobs while each block B r B contains at most one non-fixed job for the considered problem 1 | p i L p i p i U | C i . Using O ( n log n ) -Procedure 1 described in the proof of Lemma 1, we construct the set B = { B 1 , B 2 , , B m } of all blocks. Using Lemma 3, we order the jobs in the set J \ J * according to the increasing of the left bounds of the cores of their blocks. As a result, all n - | J * | jobs are linearly ordered since all jobs J \ J * are fixed in their blocks. Such an ordering of the jobs takes O ( n log n ) time due to Lemma 1.
Since each block B r B contain at most one non-fixed job, the equality B ( J u ) B ( J v ) = holds for each pair of jobs J u B ( J u ) B \ B * and J v B ( J v ) B \ B * , u v . Furthermore, the problem 1 | p i L p i p i U | C i may be decomposed into h = | J * | + | B * | subproblems P 1 , P 2 , , P | J * | , P | J * | + 1 , , P h such that the condition of Lemma 4 holds for each pair P r and P r + 1 of the adjacent subproblems, where 1 r h - 1 . Using Lemma 4, we decompose the problem 1 | p i L p i p i U | C i into h subproblems { P 1 , P 2 , , P | J * | , P | J * | + 1 , , P h } = P . The set P is partitioned into two subsets, P = P 1 P 2 , where the subset P 1 = { P 1 , P 2 , , P | J * | } contains all subproblems P f containing all blocks from the set B ( J i f ) , where J i f J * and | P 1 | = | J * | .
The subset P 2 = { P | J * | + 1 , , P h } contains all subproblems P d containing one block B r d from the set B * , | P 2 | = | B * | . If subproblem P d belongs to the set P 2 , then using O ( n ) -Procedure 3 described in the proof of Theorem 5, we construct the optimality box OB ( π ( d ) , T ( d ) ) with the largest length of the relative perimeter for the subproblem P d , where π ( d ) denotes the permutation of the jobs B r d B * and T ( d ) T . It takes O ( | B r d | ) time to construct a such optimality box OB ( π ( d ) , T ( d ) ) .
If subproblem P f belongs to the set P 1 , it is necessary to consider all | B ( J j f ) | fixings of the job J i f in the block B f j from the set B ( J j f ) = { B f 1 , B f 2 , , B f | B ( J j f ) | } . Thus, we have to solve | B ( J j f ) | subproblems P f g , where job J i f is fixed in the block B f g B ( J j f ) and job J i f is deleted from all other blocks B ( J j f ) \ { B f g } . We apply Procedure 3 for constructing the optimality box OB ( π ( g ) , T ( f ) ) with the largest length of the relative perimeter P e r OB ( π ( g ) , T ( f ) ) for each subproblem P f g , where g { 1 , 2 , , | B ( J j f ) | } . Then, we have to choose the largest length of the relative perimeter among | B ( J i f ) | constructed ones: P e r OB ( π ( f * ) , T ( f ) ) = max g { 1 , 2 , , | B ( J j f ) | } P e r OB ( π ( g ) , T ( f ) ) .
Due to Lemma 4, the optimality box OB ( π k , T ) with the largest relative perimeter for the original problem 1 | p i L p i p i U | C i is determined as the Cartesian product of the optimality boxes OB ( π ( d ) , T ( d ) ) and OB ( π ( f * ) , T ( f ) ) constructed for the subproblems P d P 2 and P f P 1 , respectively. The following equality holds: OB ( π k , T ) = × P f P 1 OB ( π ( f * ) , T ( f ) ) × ( × P d P 2 OB ( π ( d ) , T ( d ) ) ) . The permutation π k with the largest length of the relative perimeter of the optimality box OB ( π k , T ) for the problem 1 | p i L p i p i U | C i is determined as the concatenation of the corresponding permutations π ( f * ) and π ( d ) . Using the complexities of the Procedures 1 and 3, we conclude that the total complexity of the described algorithm (we call it Procedure 4) can be estimated by O ( n log n ) . ☐
Lemma 5.
Within constructing a permutation π k with the largest relative perimeter of the optimality box OB ( π k , T ) , any job J i may be moved only within the blocks B ( J i ) .
Proof. 
Let job J i be located in the block B r in the permutation π k such that J i B r . Then, either the inequality p v L > p i U or the inequality p v U < p i L holds for each job J v B r . If p v L > p i U , job J u dominates job J i (due to Theorem 2). If p v U < p i L , job J i dominates job J u . Hence, if job J i is located in the permutation π k between jobs J v B r and J w B r , then OB ( π k , T ) = due to Definition 2. ☐
Due to Lemma 5, if job J i is fixed in the block B k B (or is non-fixed but distributed to the block B k B ), then job J i is located within the jobs from the block B k in any permutation π k with the largest relative perimeter of the optimality box OB ( π k , T ) .

4. An Algorithm for Constructing a Job Permutation with the Largest Relative Perimeter of the Optimality Box

Based on the properties of the optimality box, we next develop Algorithm 2 for constructing the permutation π k for the problem 1 | p i L p i p i U | C i , whose optimality box OB ( π k , T ) has the largest relative perimeter among all permutations in the set S.
Algorithm 2
Input: Segments [ p i L , p i U ] for the jobs J i J .
Output: The permutation π k S with the largest relative perimeter P e r OB ( π k , T ) .
    Step 1: IF the condition of Theorem 3 holds
                   THEN OB ( π k , T ) = for any permutation π k S STOP.
     Step 2: IF the condition of Theorem 4 holds
                   THEN construct the permutation π k S such that P e r OB ( π k , T ) = n
                   using Procedure 2 described in the proof of Theorem 4 STOP.
     Step 3: ELSE determine the set B of all blocks using the
                    O ( n log n ) -Procedure 1 described in the proof of Lemma 1
     Step 4: Index the blocks B = { B 1 . B 2 , , B m } according to increasing
                    left bounds of their cores (Lemma 3)
     Step 5: IF J = B 1 THEN problem 1 | p i L p i p i U | C i is called problem P 1
                    (Theorem 5) set i = 0 GOTO step 8 ELSE set i = 1
     Step 6: IF there exist two adjacent blocks B r * B and B r * + 1 B such
                     that B r * B r * + 1 = ; let r denote the minimum of the above index r *
                     in the set { 1 , 2 , , m } THEN decompose the problem P into
                     subproblem P 1 with the set of jobs J 1 = k = 1 r B k and subproblem P 2
                     with the set of jobs J 2 = k = r + 1 m B k using Lemma 4;
                     set P = P 1 , J = J 1 , B = { B 1 , B 2 , , B r } GOTO step 7 ELSE
    Step 7: IF B { B 1 } THEN GOTO step 9 ELSE
     Step 8: Construct the permutation π s ( i ) with the largest relative perimeter
                     P e r OB ( π s ( i ) , T ) using Procedure 3 described in the proof of
                     Theorem 5 IF i = 0 or J 2 = B m GOTO step 12 ELSE
    Step 9: IF there exists a block in the set B containing more than one
                     non-fixed jobs THEN construct the permutation π s ( i ) with the
                     largest relative perimeter P e r OB ( π s ( i ) , T ) for the problem P 1
                     using Procedure 5 described in Section 4.1 GOTO step 11
    Step 10: ELSE construct the permutation π s ( i ) with the largest relative
                     perimeter P e r OB ( π s ( i ) , T ) for the problem P 1 using
                     O ( n log n ) -Procedure 4 described in the proof of Theorem 6
     Step 11: Construct the optimality box OB ( π s ( i ) , T ) for the permutation π s ( i )
                      using Algorithm 1 IF J 2 B m and i 1 THEN
                      set i : = i + 1 , P = P 2 , J = J 2 , B = { B r + 1 , B r + 2 , , B m }
                  GOTO step 6 ELSE IF J 2 = B m THEN GOTO step 8
     Step 12: IF i > 0 THEN set v = i , determine the permutation
                      π k = ( π s ( 1 ) , π s ( 2 ) , , π s ( v ) ) and the optimality box
                      OB ( π k , T ) = × i { 1 , 2 , , v } OB ( π s ( i ) , T ) GOTO step 13
                   ELSE OB ( π k , T ) = OB ( π s ( 0 ) , T )
     Step 13: The optimality box OB ( π k , T ) has the largest value of
                        P e r OB ( π k , T ) STOP.

4.1. Procedure 5 for the Problem 1 | p i L p i p i U | C i with Blocks Including More Than One Non-Fixed Jobs

For solving the problem P 1 at step 9 of the Algorithm 2, we use Procedure 5 based on dynamic programming. Procedure 5 allows us to construct the permutation π k S for the problem 1 | p i L p i p i U | C i with the largest value of P e r OB ( π k , T ) , where the set B consists of more than one block, m 2 , the condition of Lemma 4 does not hold for the jobs J = { J 1 , J 2 , , J n } = : J ( B m 0 ) , where B m 0 denotes the following set of blocks: { B 1 , B 2 , , B m } = : B m 0 . Moreover, the condition of Theorem 6 does hold for the set B = B m 0 of the blocks, i.e., there is a block B r B m 0 containing more than one non-fixed jobs. For the problem 1 | p i L p i p i U | C i with J = { J 1 , J 2 , , J n } = J ( B m 0 ) , one can calculate the following tight upper bound P e r m a x on the length of the relative perimeter P e r OB ( π k , T ) of the optimality box OB ( π k , T ) :
P e r m a x = 2 · | B \ B ̲ | + | B ̲ | P e r OB ( π k , T ) ,
where B ̲ denotes the set of all blocks B r B which are singletons, | B r | = 1 . The upper bound (5) on the relative perimeter P e r OB ( π k , T ) holds, since the relative optimality segment u k i * - l k i * p k i U - p k i L for any job J i J is not greater than one. Thus, the sum of the relative optimality segments for all jobs J i J cannot be greater than 2 m .
Instead of describing Procedure 5 in a formal way, we next describe the first two iterations of Procedure 5 along with the application of Procedure 5 to a small example with four blocks and three non-fixed jobs (see Section 4.2). Let T = ( V , E ) denote the solution tree constructed by Procedure 5 at the last iteration, where V is a set of the vertexes presenting states of the solution process and E is a set of the edges presenting transformations of the states to another ones. A subgraph of the solution tree T = ( V , E ) constructed at the iteration h is denoted by T h = ( V h , E h ) . All vertexes i V of the solution tree have their ranks from the set { 0 , 1 , , m = | B | } . The vertex 0 in the solution tree T h = ( V h , E h ) has a zero rank. The vertex 0 is characterized by a partial job permutation π 0 ( ; ) , where the non-fixed jobs are not distributed to their blocks.
All vertexes of the solution tree T h having the first rank are generated at iteration 1 from vertex 0 via distributing the non-fixed jobs J [ B 1 ] of the block B 1 , where J [ B 1 ] B 1 . Each job J v J [ B 1 ] must be distributed either to the block B 1 or to another block B j B with the inclusion J v J [ B j ] . Let B k t denote a set of all non-fixed jobs J i B k , which are not distributed to their blocks at the iterations with the numbers less than t. A partial permutation of the jobs is characterized by the notation π u ( B k ; J [ u ] ) , where u denotes the vertex u V t in the constructed solution tree T t = ( V t , E t ) and J [ u ] denotes the non-fixed jobs from the set J [ B k ] , which are distributed to the block B k in the vertex j V t of the solution tree such that the arc ( j , u ) belongs to the set E t .
At the first iteration of Procedure 5, the set P ( J [ B 1 1 ] ) = { J [ B 1 1 ] , , } of all subsets of the set J [ B 1 1 ] is constructed and 2 | J [ B 1 1 ] | partial permutations are generated for all subsets P ( J [ B 1 1 ] ) of the non-fixed jobs J [ B 1 1 ] . The constructed solution tree T 1 = ( V 1 , E 1 ) consists of the vertexes 0 , 1 , , 2 | J [ B 1 1 ] | and 2 | J [ B 1 1 ] | arcs connecting vertex 0 with the other vertexes in the tree T 1 . For each generated permutation π u ( B k ; J [ u ] ) , where J [ u ] P ( J [ B k l ] ) , the penalty ϕ u determined in (6) is calculated, which is equal to the difference between the lengths of the maximal possible relative perimeter P e r m a x of the optimality box OB ( π k , T ) and the relative perimeter of the optimality box OB ( π u ( B k ; J [ u ] ) , T ) , which may be constructed for the permutation π u ( B k ; J [ u ] ) :
P e r OB ( π u ( B k ; J [ u ] ) , T ) = i k P e r m a x u - ϕ u ,
where P e r m a x u denotes the maximal length of the relative perimeter of the permutation π u ( B k ; J [ u ] ) , T ) . The penalty ϕ u is calculated using O ( n ) -Procedure 3 described in the proof of Theorem 5. The complete permutation π 0 u ( B k ; J [ u ] ) with the end π u ( B k ; J [ u ] ) is determined based on the permutations π s ( B c ; J [ s ] ) , where each vertex s belongs to the chain ( 0 u ) between vertexes 0 and u in the solution tree T t = ( V t , E t ) and each block B c belongs to the set B u = { B 1 , B 2 , , B k } . The permutation π 0 u ( B k ; J [ u ] ) includes all jobs, which are fixed in the blocks B c B u or distributed to their blocks B c B u in the optimal order for the penalty ϕ u .
The aim of Procedure 5 is to construct a complete job permutation π f ( B m ; J [ f ] ) = π k S such that the penalty ϕ f is minimal for all job permutations from the set S. At the next iteration, a partial permutation π s ( B 2 ; J [ s ] ) is chosen from the constructed solution tree such that the penalty ϕ s is minimal among the permutations corresponding to the leafs of the constructed solution tree.
At the second iteration, the set P ( J [ B 2 2 ] ) = { J [ B 2 2 ] , , } of all subsets of the set J [ B 2 2 ] is generated and 2 | J [ B 2 2 ] | permutations for all subsets P ( J [ B 2 2 ] ) of the jobs from the block B 2 are constructed. For each generated permutation π v ( B 2 2 ; J [ v ] ) , where J [ v ] P ( J [ B 2 2 ] ) , the penalty ϕ v is calculated using the equality ϕ v = ϕ l + Δ ϕ k , where the edge [ l , v ] belongs to the solution tree T 2 = ( V 2 , E 2 ) and Δ ϕ k denotes the penalty reached for the optimal permutation π 0 v ( B 2 ; J [ v ] ) constructed from the permutation π v ( B 1 ; J [ v ] ) using O ( n ) -Procedure 3. For the consideration at the next iteration, one chooses the partial permutation π d ( B c ; J [ d ] ) with the minimal value of the penalty for the partial permutations in the leaves of the constructed solution tree.
The whole solution tree is constructed similarly until there is a partial permutation with a smaller value of the penalty ϕ t in the constructed solution tree.

4.2. The Application of Procedure 5 to the Small Example

Table 1 presents input data for the example of the problem 1 | p i L p i p i U | C i described in Section 3.1. The jobs J 4 , J 5 and J 7 are non-fixed: J [ B 1 ] = { J 4 , J 5 } , J [ B 2 ] = { J 4 , J 5 , J 7 } , J [ B 3 ] = { J 4 , J 6 , J 7 } , J [ B 4 ] = { J 7 } . The job J 4 must be distributed either to the block B 1 , B 2 , or to the block B 3 . The job J 5 must be distributed either to the block B 1 , or to the block B 2 . The job J 7 must be distributed either to the block B 2 , B 3 , or to the block B 4 . The relative perimeter of the optimality box OB ( π k , T ) for any job permutation π k S cannot be greater than P e r m a x = 4 × 2 = 8 due to the upper bound on the relative perimeter P e r OB ( π k , T ) given in (5).
At the first iteration of Procedure 5, the set P ( J [ B 1 1 ] ) = { , { J 4 } , { J 5 } , { J 4 , J 5 } } is constructed and permutations π 1 ( B 1 1 ; ) , π 2 ( B 1 1 ; J 4 ) , π 3 ( B 1 1 ; J 5 ) and π 4 ( B 1 1 ; J 4 , J 5 ) are generated. For each element of the set P ( J [ B 1 1 ] ) , we construct a permutation with the maximal length of the relative perimeter of the optimality box and calculate the penalty. We obtain the following permutations with their penalties: π 0 1 ( B 1 1 ; ) = ( J 1 , J 2 , J 3 ) , ϕ 1 = 1 19 30 1 . 633333 ; π 0 2 ( B 1 1 ; J 4 ) = ( J 4 , J 2 , J 1 , J 3 ) , ϕ 2 = 1 , 5 ; π 0 3 ( B 1 1 ; J 5 ) = ( J 1 , J 5 , J 2 , J 3 ) , ϕ 3 = 1 13 30 1 . 433333 ; π 0 4 ( B 1 1 ; J 4 , J 5 ) = ( J 4 , J 5 , J 1 , J 2 , J 3 ) , ϕ 4 = 1 13 30 1 . 433333 .
At the second iteration, the block B 2 is destroyed, and we construct the permutations π 5 ( B 3 2 ; ) and π 6 ( B 3 2 ; J 7 ) from the permutation π 4 ( B 1 1 ; J 4 , J 5 ) . We obtain the permutation π 0 5 ( B 3 2 ; ) = ( J 4 , J 5 , J 1 , J 2 , J 3 , J 6 ) with the penalty ϕ 5 = 4 13 30 4 . 433333 and the permutation π 0 6 ( B 2 3 ; J 7 ) = ( J 4 , J 5 , J 1 , J 2 , J 3 , J 7 , J 6 ) with the penalty ϕ 6 = 5 1 3 5 . 333333 . Since all non-fixed jobs are distributed in the permutation π 0 6 ( B 1 1 ; J 3 , J 8 ) , we obtain the complete permutation J 4 , J 5 , J 1 , J 2 , J 3 , J 6 , J 8 , J 10 , J 9 , J 7 ) S with the final penalty ϕ 6 * = 6 7 12 6 . 583333 . From the permutation π 0 3 ( B 1 1 ; J 5 ) , we obtain the permutations with their penalties: π 0 7 ( B 3 3 ; ) = ( J 1 , J 5 , J 3 , J 2 , J 4 , J 6 ) , ϕ 7 = 5 29 90 5 . 322222 and π 0 8 ( B 3 3 ; J 7 ) = ( J 1 , J 5 , J 3 , J 2 , J 4 , J 7 , J 6 ) , ϕ 8 = 51 . We obtain the complete permutation π = ( J 1 , J 5 , J 3 , J 2 , J 4 , J 7 , J 6 , J 9 , J 10 , J 8 ) with the penalty ϕ 8 * = 6 . 35 .
We obtain the following permutations with their penalties: π 0 9 ( B 2 4 ; ) = ( J 4 , J 2 , J 3 , J 1 , J 5 ) , ϕ 9 = 3 1 24 3 . 041667 and π 0 10 ( B 2 4 ; J 7 ) = ( J 4 , J 2 , J 1 , J 3 , J 7 , J 5 ) , ϕ 10 = 3 . 5 from the permutation π 0 2 ( B 1 1 ; J 4 ) . We obtain the following permutations with their penalties: π 0 11 ( B 2 5 ; ) = ( J 1 , J 2 , J 3 , J 5 , ) , ϕ 11 = 3 . 175 , π 0 12 ( B 2 5 ; J 4 ) = ( J 1 , J 2 , J 3 , J 4 , J 5 ) , ϕ 12 = 3 . 3 , π 0 13 ( B 2 5 ; J 7 ) = ( J 1 , J 2 , J 3 , J 7 , J 5 ) , ϕ 13 = 3 19 30 3 . 633333 , π 0 14 ( B 2 5 ; J 4 , J 7 ) = ( J 1 , J 2 , J 3 , J 4 , J 7 , J 5 ) , ϕ 14 = 3 19 30 3 . 633333 from the permutation π 0 1 ( B 1 1 ; ) . We obtain the complete permutation ( J 1 , J 2 , J 3 , J 4 , J 7 , J 5 , J 6 , J 9 , J 10 , J 8 ) S with the final penalty ϕ 14 * = 5 53 60 5 . 883333 . We obtain the following permutations with their penalties: π 0 15 ( B 3 6 ; ) = ( J 4 , J 2 , J 3 , J 1 , J 5 , J 6 ) , ϕ 15 = 4 1 24 4 . 041667 , π 0 16 ( B 3 6 ; J 7 ) = ( J 4 , J 2 , J 3 , J 1 , J 5 , J 7 , J 6 ) , ϕ 16 = 5 7 60 5 . 116667 from the permutation π 0 9 ( B 2 4 ; ) . We obtain the complete permutation ( J 4 , J 2 , J 3 , J 1 , J 5 , J 7 , J 6 , J 9 , J 10 , J 8 ) S with the final penalty ϕ 16 * = 6 11 30 6 . 366667 .
We obtain the following permutations with their penalties: π 0 17 ( B 3 7 ; ) = ( J 1 , J 2 , J 3 , J 5 , J 4 , J 6 ) , ϕ 17 = 5 11 45 5 . 244444 , π 0 18 ( B 3 7 ; J 7 ) = ( J 1 , J 2 , J 3 , J 5 , J 7 , J 4 , J 6 ) , ϕ 18 = 4 . 925 from the permutation π 0 11 ( B 2 5 ; ) . We obtain the complete permutation ( J 1 , J 2 , J 3 , J 5 , J 7 , J 4 , J 6 , J 9 , J 10 , J 8 ) S with the final penalty ϕ 18 * = 6 . 175 .
We obtain the following permutations with their penalties: π 0 19 ( B 3 8 ; ) = ( J 1 , J 2 , J 3 , J 4 , J 5 , J 6 ) , ϕ 19 = 4 . 3 , π 0 20 ( B 3 8 ; J 7 ) = ( J 1 , J 2 , J 3 , J 4 , J 5 , J 7 , J 6 ) , ϕ 20 = 5 . 7 from the permutation π 0 12 ( B 2 5 ; J 4 ) . We obtain the complete permutation ( J 1 , J 2 , J 3 , J 4 , J 5 , J 7 , J 6 , J 9 , J 10 , J 8 ) S with the final penalty ϕ 20 * = 6 . 95 .
From the permutation π 0 10 ( B 2 4 ; J 7 ) , we obtain the permutation with its penalty as follows: π 0 21 ( B 3 9 ; J 4 ) = ( J 4 , J 2 , J 1 , J 3 , J 7 , J 5 , J 4 , J 6 ) , ϕ 21 = 5 . 05 . We obtain the complete permutation J 4 , J 2 , J 1 , J 3 , J 7 , J 5 , J 4 , J 6 , J 9 , J 10 , J 8 ) S with the final penalty ϕ 21 * = 6 . 3 . We obtain the following permutation with their penalties: π 0 22 ( B 3 10 ; J 4 ) = ( J 1 , J 2 , J 3 , J 7 , J 5 , J 4 , J 6 ) , ϕ 22 = 5 1 12 5 . 083333 from the permutation π 0 13 ( B 2 5 ; J 7 ) . We obtain the complete permutation ( J 1 , J 2 , J 3 , J 7 , J 5 , J 4 , J 6 , J 9 , J 10 , J 8 ) S with the final penalty ϕ 22 * = 6 1 3 6 . 333333 . We obtain the complete permutation π 0 23 ( B 4 11 ; J 4 ) = ( J 4 , J 2 , J 3 , J 1 , J 5 , J 6 , J 8 , J 10 , J 9 , J 7 ) , ϕ 23 = 5 17 120 5 . 141667 from the permutation π 0 15 ( B 3 6 ; ) . We obtain the complete permutation π 0 24 ( B 4 12 ; J 4 ) = ( J 1 , J 2 , J 3 , J 4 , J 5 , J 6 , J 8 , J 10 , J 9 , J 7 ) , ϕ 22 = 5 . 4 from the permutation π 0 19 ( B 3 8 ; ) ) . We obtain the complete permutation π 0 25 ( B 4 12 ; J 4 ) = ( J 4 , J 5 , J 1 , J 2 , J 3 , J 6 , J 8 , J 10 , J 9 , J 7 ) , ϕ 25 = 5 8 15 5 . 533333 from the permutation π 0 5 ( B 3 2 ; ) ) .
Using Procedure 5, we obtain the following permutation with the largest relative perimeter of the optimality box: π 0 23 ( B 4 11 ; J 4 ) . The maximal relative perimeter P e r ( OB ( π k , T ) ) of the optimality box is equal to 2 103 120 2 . 858333 , where P e r m a x = 22 and the minimal penalty obtained for the permutation π k is equal to 5 17 120 5 . 141667 .
Since all non-fixed jobs are distributed in the permutation π 0 23 ( B 4 11 ; J 4 ) , we obtain the complete permutation ( J 4 , J 2 , J 3 , J 1 , J 5 , J 6 , J 8 , J 10 , J 9 , J 7 ) S with the final penalty ϕ 23 * equal to 5 17 120 5 . 141667 .

5. An Approximate Solution to the Problem 1 | p i L p i p i U | C i

The relative perimeter of the optimality box OB ( π k , T ) characterizes the probability for the permutation π k to be optimal for the instances 1 | p | C i , where p T . It is clear that this probability may be close to zero for the problem 1 | p i L p i p i U | C i with a high uncertainty of the job processing times (if the set T has a large volume and perimeter).
If the uncertainty of the input data is high for the problem 1 | p i L p i p i U | C i , one can estimate how the value of i = 1 n C i ( π k , p ) with a vector p T may be close to the optimal value of i = 1 n C i ( π t , p * ) , where the permutation π t S is optimal for the factual scenario p * T of the job processing times. We call the scenario p * = ( p 1 * , p 2 * , , p n * ) T factual, if p i is equal to the exact time needed for processing the job J i J . The factual processing time p i * becomes known after completing the job J i J .
If the permutation π k = ( π k 1 , π k 2 , , π k n ) S has the non-empty optimality box OB ( π k , T ) , then one can calculate the following error function:
F ( π k , T ) = i = 1 n 1 - u k i * - l k i * p k i U - p k i L n - i + 1 .
A value of the error function F ( π k , T ) characterizes how the objective function value of i = 1 n C i ( π k , p * ) for the permutation π k may be close to the objective function value of i = 1 n C i ( π t , p * ) for the permutation π t S , which is optimal for the factual scenario p * T of the job processing times. The function F ( π k , T ) characterizes the following difference
i = 1 n C i ( π k , p * ) - i = 1 n C i ( π t , p * ) ,
which has to be minimized for a good approximate solution π k to the uncertain problem 1 | p i L p i p i U | C i . The better approximate solution π k to the uncertain problem 1 | p i L p i p i U | C i will have a smaller value of the error function F ( π k , T ) .
The formula (7) is based on the cumulative property of the objective function i = 1 n C i ( π k , T ) , namely, each relative error 1 - u k i * - l k i * p k i U - p k i L > 0 obtained due to the wrong position of the job J k i in the permutation π k is repeated ( n - i ) times for all jobs, which succeed the job J k i in the permutation π k . Therefore, a value of the error function F ( π k , T ) must be minimized for a good approximation of the value of i = 1 n C i ( π t , T ) for the permutation π k .
If the equality P e r OB ( π k , T ) = 0 holds, the error function F ( π k , T ) has the maximal possible value determined as follows: F ( π k , T ) = i = 1 n 1 - u k i * - l k i * p k i U - p k i L n - i + 1 = i = 1 n n - i + 1 = n ( n + 1 ) 2 . The necessary and sufficient condition for the largest value of F ( π k , T ) = n ( n + 1 ) 2 is given in Theorem 3.
If the equality P e r OB ( π k , T ) = n holds, the error function F ( π k , T ) has the smallest value equal to 0: F ( π k , T ) = i = 1 n 1 - u k i * - l k i * p k i U - p k i L n - i + 1 = i = 1 n 1 - 1 n - i + 1 = 0 . The necessary and sufficient condition for the smallest value of F ( π k , T ) = 0 is given in Theorem 4, where the permutation π k S is optimal for any factual scenario p * T of the job processing times.
Due to evident modifications of the proofs given in Section 3.3, it is easy to prove that Theorems 5 and 6 remain correct in the following forms.
Theorem 7.
If the equality B 1 = J holds, then it takes O ( n ) time to find the permutation π k S and optimality box OB ( π k , T ) with the smallest value of the error function F ( π k , T ) among all permutations S.
Theorem 8.
Let each block B r B contain at most one non-fixed job. The permutation π k S with the smallest value of the error function F ( π k , T ) among all permutations S is constructed in O ( n log n ) time.
Using Theorems 7 and 8, we developed the modifications of Procedures 3 and 4 for the minimization of the values of F ( π k , T ) instead of the maximization of the values of P e r OB ( π k , T ) . The derived modifications of Procedures 3 and 4 are called Procedures 3 + F ( π k , T ) and 4 + F ( π k , T ) , respectively. We modify also Procedures 2 and 5 for minimization of the values of F ( π k , T ) instead of the maximization of the values of P e r OB ( π k , T ) . The derived modifications of Procedures 2 and 5 are called Procedures 2 + F ( π k , T ) and 5 + F ( π k , T ) , respectively. Based on the proven properties of the optimality box (Section 3), we propose the following Algorithm 3 for constructing the job permutation π k S for the problem 1 | p i L p i p i U | C i , whose optimality box OB ( π k , T ) provides the minimal value of the error function F ( π k , T ) among all permutations S.
Algorithm 3
Input: Segments [ p i L , p i U ] for the jobs J i J .
Output: The permutation π k S and optimality box OB ( π k , T ) , which provide
the minimal value of the error function F ( π k , T ) .
     Step 1: IF the condition of Theorem 3 holds
                    THEN OB ( π k , T ) = for any permutation π k S
                     and the equality F ( π k , T ) = n ( n + 1 ) 2 holds STOP.
     Step 2: IF the condition of Theorem 4 holds
                     THEN using Procedure 2 + F ( π k , T ) construct
                     the permutation π k S such that both equalities
                     P e r OB ( π k , T ) = n and F ( π k , T ) = 0 hold STOP.
     Step 3: ELSE determine the set B of all blocks using the
                     O ( n log n ) -Procedure 1 described in the proof of Lemma 1
     Step 4: Index the blocks B = { B 1 . B 2 , , B m } according to increasing
                     left bounds of their cores (Lemma 3)
     Step 5: IF J = B 1 THEN problem 1 | p i L p i p i U | C i is called problem P 1
                    (Theorem 5) set i = 0 GOTO step 8 ELSE set i = 1
     Step 6: IF there exist two adjacent blocks B r * B and B r * + 1 B such
                     that B r * B r * + 1 = ; let r denote the minimum of the above index r *
                     in the set { 1 , 2 , , m } THEN decompose the problem P into
                     subproblem P 1 with the set of jobs J 1 = k = 1 r B k and subproblem P 2
                     with the set of jobs J 2 = k = r + 1 m B k using Lemma 4;
                     set P = P 1 , J = J 1 , B = { B 1 , B 2 , , B r } GOTO step 7 ELSE
     Step 7: IF B { B 1 } THEN GOTO step 9 ELSE
     Step 8: Construct the permutation π s ( i ) with the minimal value of
                     the error function F ( π k , T ) using Procedure 3 + F ( π k , t )
                     IF i = 0 or J 2 = B m GOTO step 12 ELSE
     Step 9: IF there exists a block in the set B containing more than one
                     non-fixed jobs THEN construct the permutation π s ( i ) with
                     the minimal value of the error function F ( π k , T ) for the problem P 1
                     using Procedure 5 + F ( π k , t ) GOTO step 11
     Step 10: ELSE construct the permutation π s ( i ) with the minimal value of the
                     error function F ( π k , T ) for the problem P 1 using Procedure 3 + F ( π k , t )
     Step 11: Construct the optimality box OB ( π s ( i ) , T ) for the permutation π s ( i )
                     using Algorithm 1 IF J 2 B m and i 1 THEN
                      set i : = i + 1 , P = P 2 , J = J 2 , B = { B r + 1 , B r + 2 , , B m }
                      GOTO step 6 ELSE IF J 2 = B m THEN GOTO step 8
     Step 12: IF i > 0 THEN set v = i , determine the permutation
                       π k = ( π s ( 1 ) , π s ( 2 ) , , π s ( v ) ) and the optimality box:
                      OB ( π k , T ) = × i { 1 , 2 , , v } OB ( π s ( i ) , T ) GOTO step 13
                      ELSE OB ( π k , T ) = OB ( π s ( 0 ) , T )
     Step 13: The optimality box OB ( π k , T ) has the minimal value
                      of the error function F ( π k , T ) STOP.
In Section 6, we describe the results of the computational experiments on applying Algorithm 3 to the randomly generated problems 1 | p i L p i p i U | C i .

6. Computational Results

For the benchmark instances 1 | p i L p i p i U | C i , where there are no properties of the randomly generated jobs J , which make the problem harder, the mid-point permutation π m i d - p = π e S , where all jobs J i J are ordered according to the increasing of the mid-points p i U + p i L 2 of their segments [ p i L , p i U ] , is often close to the optimal permutation. In our computational experiments, we tested seven classes of harder problems, where the job permutation π k S constructed by Algorithm 3 outperforms the mid-point permutation π m i d - p and the permutation π m a x constructed by Algorithm MAX-OPTBOX derived in [15]. Algorithm MAX-OPTBOX and Algorithm 3 were coded in C# and tested on a PC with Intel Core (TM) 2 Quad, 2.5 GHz, 4.00 GB RAM. For all tested instances, inequalities p i L < p i U hold for all jobs J i J . Table 2 presents computational results for randomly generated instances of the problem 1 | p i L p i p i U | C i with n { 100 , 500 , 1000 , 5000 , 10 , 000 } . The segments of the possible processing times have been randomly generated similar to that in [15].
An integer center C of the segment [ p i L , p i U ] was generated using a uniform distribution in the range [ 1 , 100 ] . The lower bound p i L of the possible processing time p i was determined using the equality p i L = C · ( 1 - δ 100 ) . Hereafter, δ denotes the maximal relative error of the processing times p i due to the given segments [ p i L , p i U ] . The upper bound p i U was determined using the equality p i U = C · ( 1 + δ 100 ) . Then, for each job J i J , the point p ̲ i was generated using a uniform distribution in the range [ p i L , p i U ] . In order to generate instances, where all jobs J belong to a single block, the segments [ p i L , p i U ] of the possible processing times were modified as follows: [ p ˜ i L , p ˜ i U ] = [ p i L + p ̲ - p ̲ i , p i U + p ̲ - p ̲ i ] , where p ̲ = max i = 1 n p ̲ i . Since the inclusion p ̲ [ p ˜ i L , p ˜ i U ] holds, each constructed instance contains a single block, | B | = 1 . The maximum absolute error of the uncertain processing times p i , J i J , is equal to max i = 1 n ( p i U - p i L ) , and the maximum relative error of the uncertain processing times p i , J i J , is not greater than 2 δ % . We say that these instances belong to class 1.
Similarly as in [15], three distribution laws were used in our experiments to determine the factual processing times of the jobs. (We remind that if inequality p i L < p i U holds, then the factual processing time of the job J i becomes known after completing the job J i .) We call the uniform distribution as the distribution law with number 1, the gamma distribution with the parameters α = 9 and β = 2 as the distribution law with number 2 and the gamma distribution with the parameters α = 4 and β = 2 as the distribution law with number 3. In each instance of class 1, for generating the factual processing times for different jobs of the set J , the number of the distribution law was randomly chosen from the set { 1 , 2 , 3 } . We solved 15 series of the randomly generated instances from class 1. Each series contains 10 instances with the same combination of n and δ .
In the conducted experiments, we answered the question of how large the obtained relative error Δ = γ p * k - γ p * t γ p * t · 100 % of the value γ p * k of the objective function γ = i = 1 n C i was for the permutation π k with the minimal value of F ( π k , T ) with respect to the actually optimal objective function value γ p * t calculated for the factual processing times p * = ( p 1 * , p 2 * , , p n * ) T . We also answered the question of how small the obtained relative error Δ of the value γ p * k of the objective function C i was for the permutation π k with the minimal value of F ( π k , T ) . We compared the relative error Δ with the relative error Δ m i d - p of the value γ p * m of the objective function C i for the permutation π m i d - p obtained for determining the job processing times using the mid-points of the given segments. We compared the relative error Δ with the relative error Δ m a x of the value of the objective function C i for the permutation π m a x constructed by Algorithm MAX-OPTBOX derived in [15].
The number n of jobs in the instance is given in column 1 in Table 2. The half of the maximum possible errors δ of the random processing times (in percentage) is given in column 2. Column 3 gives the average error Δ for the permutation π k with the minimal value of F ( π k , T ) . Column 4 presents the average error Δ m i d - p obtained for the mid-point permutations π m i d - p , where all jobs are ordered according to increasing mid-points of their segments. Column 5 presents the average relative perimeter of the optimality box OB ( π k , T ) for the permutation π k with the minimal value of F ( π k , T ) . Column 6 presents the relation Δ m i d - p / Δ . Column 7 presents the relation Δ m a x / Δ . Column 8 presents the average CPU-time of Algorithm 3 for the solved instances in seconds.
The computational experiments showed that for all solved examples of class 1, the permutations π k with the minimal values of F ( π k , T ) for their optimality boxes generated good objective function values γ p * k , which are smaller than those obtained for the permutations π m i d - p and for the permutations π m a x . The smallest errors, average errors, largest errors for the tested series of the instances are presented in the last rows of Table 2.
In the second part of our experiments, Algorithm 3 was applied to the randomly generated instances from other hard classes 2–7 of the problem 1 | p i L p i p i U | C i . We randomly generated non-fixed jobs J 1 , J 2 , , J s , which belong to all blocks B 1 , B 2 , , B m of the randomly generated n - s fixed jobs. The lower bound p i L and the upper bound p i U on the feasible values of p i R + 1 of the processing times of the fixed jobs, p i [ p i L , p i U ] , were generated as follows. We determined a bound of blocks [ b ˜ i L , b ˜ i U ] for generating the cores of the blocks [ b i L , b i U ] [ b ˜ i L , b ˜ i U ] and for generating the segments [ p i L , p i U ] for the processing times of | B i | jobs from all blocks B i , i { 1 , 2 , 3 } , [ b i L , b i U ] [ p i L , p i U ] [ b ˜ i L , b ˜ i U ] . Each instance in class 2 has fixed jobs J i J with rather closed centers ( p i L + p i U ) / 2 and large difference between segment lengths p i U - p i L .
Each instance in class 3 or in class 4 has a single non-fixed job J v , whose bounds are determined as follows: p J v L b ˜ 1 L b ˜ 1 U < b ˜ 2 L b ˜ 2 U < b ˜ 3 L b ˜ 3 U p J v U . Classes 3 and 4 of the solved instances differ one from another by the numbers of non-fixed jobs and the distribution laws used for choosing the factual processing times of the jobs J . Each instance from classes 5 and 6 has two non-fixed jobs. In each instance from classes 2, 3, 5, 6 and 7, for generating the factual processing times for the jobs J , the numbers of the distribution law were randomly chosen from the set { 1 , 2 , 3 } , and they are indicated in column 4 in Table 3. In the instances of class 7, the cores of the blocks were determined in order to generate different numbers of non-fixed jobs in different instances. The numbers of non-fixed jobs were randomly chosen from the set { 2 , 3 , , 8 } . Numbers n of the jobs are presented in column 1. In Table 3, column 2 represents the number | B | of blocks in the solved instance and column 3 the number of non-fixed jobs. The distribution laws used for determining the factual job processing times are indicated in column 4 in Table 3. Each solved series contained 10 instances with the same combination of n and the other parameters. The obtained smallest, average and largest values of Δ , Δ m i d - p , Δ m i d - p Δ and Δ m a x Δ for each series of the tested instances are presented in columns 5, 6, 8 and 9 in Table 3 at the end of series. Column 7 presents the average relative perimeter of the optimality box OB ( π k , T ) for the permutation π k with the minimal value of F ( π k , T ) . Column 10 presents the average CPU-time of Algorithm 3 for the solved instances in seconds.

7. Concluding Remarks

The uncertain problem 1 | p i L p i p i U | C i continues to attract the attention of the OR researchers since the problem is widely applicable in real-life scheduling and is commonly used in many multiple-resource scheduling systems, where only one of the machines is the bottleneck and uncertain. The right scheduling decisions allow the plant to reduce the costs of productions due to better utilization of the machines. A shorter delivery time is archived with increasing customer satisfaction. In Section 2, Section 3, Section 4, Section 5 and Section 6, we used the notion of an optimality box of a job permutation π k and proved useful properties of the optimality box OB ( π k , T ) . We investigated permutation π k with the largest relative perimeter of the optimality box. Using these properties, we derived efficient algorithms for constructing the optimality box for a job permutation π k with the largest relative perimeter of the box OB ( π k , T ) .
From the computational experiments, it follows that the permutation π k with the smallest values of the error function F ( π k , t ) for the optimality box OB ( π k , T ) is close to the optimal permutation, which can be determined after completing the jobs when their processing times became known. In our computational experiments, we tested classes 1–7 of hard problems 1 | p i L p i p i U | C i , where the permutation constructed by Algorithm 3 outperforms the mid-point permutation, which is often used in the published algorithms applied to the problem 1 | p i L p i p i U | C i . The minimal, average and maximal errors Δ of the objective function values were 0 . 045303 % , 0 . 735154 % and 4 . 773618 % , respectively, for the permutations with smallest values of the error function F ( π k , t ) for the optimality boxes. The minimal, average and maximal errors Δ m i d - p of the objective function values were 0 . 05378 % , 0 . 936243 % and 6 . 755918 % , respectively, for the mid-point permutations. The minimal, average and maximal errors Δ m a x of the objective function values were 0 . 04705 % , 0 . 82761 % and 6 . 2441066 % , respectively. Thus, Algorithm 3 solved all hard instances with a smaller error Δ than other tested algorithms. The average relation Δ m i d - p Δ for the obtained errors for all instances of classes 1–7 was equal to 1 . 33235 . The average relation Δ m a x Δ for the obtained errors for all instances of classes 1–7 was equal to 1 . 1133116 .

Author Contributions

Y.N. proved theoretical results; Y.N. and N.E. jointly conceived and designed the algorithms; N.E. performed the experiments; Y.N. and N.E. analyzed the data; Y.N. wrote the paper.

Conflicts of Interest

The authors declare no conflict of interest.

References

  1. Davis, W.J.; Jones, A.T. A real-time production scheduler for a stochastic manufacturing environment. Int. J. Prod. Res. 1988, 1, 101–112. [Google Scholar] [CrossRef]
  2. Pinedo, M. Scheduling: Theory, Algorithms, and Systems; Prentice-Hall: Englewood Cliffs, NJ, USA, 2002. [Google Scholar]
  3. Daniels, R.L.; Kouvelis, P. Robust scheduling to hedge against processing time uncertainty in single stage production. Manag. Sci. 1995, 41, 363–376. [Google Scholar] [CrossRef]
  4. Sabuncuoglu, I.; Goren, S. Hedging production schedules against uncertainty in manufacturing environment with a review of robustness and stability research. Int. J. Comput. Integr. Manuf. 2009, 22, 138–157. [Google Scholar] [CrossRef]
  5. Sotskov, Y.N.; Werner, F. Sequencing and Scheduling with Inaccurate Data; Nova Science Publishers: Hauppauge, NY, USA, 2014. [Google Scholar]
  6. Pereira, J. The robust (minmax regret) single machine scheduling with interval processing times and total weighted completion time objective. Comput. Oper. Res. 2016, 66, 141–152. [Google Scholar] [CrossRef]
  7. Grabot, B.; Geneste, L. Dispatching rules in scheduling: A fuzzy approach. Int. J. Prod. Res. 1994, 32, 903–915. [Google Scholar] [CrossRef]
  8. Kasperski, A.; Zielinski, P. Possibilistic minmax regret sequencing problems with fuzzy parameteres. IEEE Trans. Fuzzy Syst. 2011, 19, 1072–1082. [Google Scholar] [CrossRef]
  9. Özelkan, E.C.; Duckstein, L. Optimal fuzzy counterparts of scheduling rules. Eur. J. Oper. Res. 1999, 113, 593–609. [Google Scholar] [CrossRef]
  10. Braun, O.; Lai, T.-C.; Schmidt, G.; Sotskov, Y.N. Stability of Johnson’s schedule with respect to limited machine availability. Int. J. Prod. Res. 2002, 40, 4381–4400. [Google Scholar] [CrossRef]
  11. Sotskov, Y.N.; Egorova, N.M.; Lai, T.-C. Minimizing total weighted flow time of a set of jobs with interval processing times. Math. Comput. Model. 2009, 50, 556–573. [Google Scholar] [CrossRef]
  12. Sotskov, Y.N.; Lai, T.-C. Minimizing total weighted flow time under uncertainty using dominance and a stability box. Comput. Oper. Res. 2012, 39, 1271–1289. [Google Scholar] [CrossRef]
  13. Graham, R.L.; Lawler, E.L.; Lenstra, J.K.; Kan, A.H.G.R. Optimization and Approximation in Deterministic Sequencing and Scheduling. Ann. Discret. Appl. Math. 1979, 5, 287–326. [Google Scholar]
  14. Smith, W.E. Various optimizers for single-stage production. Nav. Res. Logist. Q. 1956, 3, 59–66. [Google Scholar] [CrossRef]
  15. Lai, T.-C.; Sotskov, Y.N.; Egorova, N.G.; Werner, F. The optimality box in uncertain data for minimising the sum of the weighted job completion times. Int. J. Prod. Res. 2017. [CrossRef]
  16. Burdett, R.L.; Kozan, E. Techniques to effectively buffer schedules in the face of uncertainties. Comput. Ind. Eng. 2015, 87, 16–29. [Google Scholar] [CrossRef]
  17. Goren, S.; Sabuncuoglu, I. Robustness and stability measures for scheduling: Single-machine environment. IIE Trans. 2008, 40, 66–83. [Google Scholar] [CrossRef]
  18. Kasperski, A.; Zielinski, P. A 2-approximation algorithm for interval data minmax regret sequencing problems with total flow time criterion. Oper. Res. Lett. 2008, 36, 343–344. [Google Scholar] [CrossRef]
  19. Kouvelis, P.; Yu, G. Robust Discrete Optimization and Its Application; Kluwer Academic Publishers: Boston, MA, USA, 1997. [Google Scholar]
  20. Lu, C.-C.; Lin, S.-W.; Ying, K.-C. Robust scheduling on a single machine total flow time. Comput. Oper. Res. 2012, 39, 1682–1691. [Google Scholar] [CrossRef]
  21. Yang, J.; Yu, G. On the robust single machine scheduling problem. J. Comb. Optim. 2002, 6, 17–33. [Google Scholar] [CrossRef]
  22. Harikrishnan, K.K.; Ishii, H. Single machine batch scheduling problem with resource dependent setup and processing time in the presence of fuzzy due date. Fuzzy Optim. Decis. Mak. 2005, 4, 141–147. [Google Scholar] [CrossRef]
  23. Allahverdi, A.; Aydilek, H.; Aydilek, A. Single machine scheduling problem with interval processing times to minimize mean weighted completion times. Comput. Oper. Res. 2014, 51, 200–207. [Google Scholar] [CrossRef]
Figure 1. The segments [ p i L , p i U ] given for the feasible processing times of the jobs J i J = { J 1 , J 2 , , J 10 } (the cores of the blocks B 1 , B 2 , B 3 and B 4 are dashed).
Figure 1. The segments [ p i L , p i U ] given for the feasible processing times of the jobs J i J = { J 1 , J 2 , , J 10 } (the cores of the blocks B 1 , B 2 , B 3 and B 4 are dashed).
Algorithms 11 00066 g001
Table 1. Input data for the problem 1 | p i L p i p i U | C i .
Table 1. Input data for the problem 1 | p i L p i p i U | C i .
i12345678910
p i L 676181715242526
p i U 11111219162135282727
Table 2. Computational results for randomly generated instances with a single block (class 1).
Table 2. Computational results for randomly generated instances with a single block (class 1).
n δ ( % ) Δ ( % ) Δ mid - p ( % ) Per OB ( π k , T ) Δ mid - p / Δ Δ max / Δ CPU-Time (s)
12345678
10010.087150.1972311.62.2631141.270220.046798
10050.3050880.3177771.8567681.0415891.0142610.031587
100100.4982860.5007311.9160641.0010771.0002780.033953
50010.0955480.2083431.62.180521.03850.218393
50050.2739330.3190281.9090911.1646231.0172350.2146
500100.4691460.4860971.9489881.0361331.0069770.206222
100010.0931470.216321.6666672.3223441.0908320.542316
100050.2649710.3152611.9090911.1897951.0307890.542938
1000100.4724710.4941421.9521431.0458661.0008320.544089
500010.0958240.2178741.6666672.2736831.0060187.162931
500050.2643950.3196451.9090911.2089651.0023367.132647
5000100.4510690.4814211.9523811.067291.006417.137556
10,00010.0957150.2174561.6666672.2719051.00343325.52557
10,00050.261980.3168551.9090911.2094631.00325125.5448
10,000100.4546550.4861051.9523811.0691751.00380925.50313
Minimum0.087150.1972311.61.0010771.0002780.031587
Average0.2788920.3396191.8276731.4897031.0330126.692502
Maximum0.4982860.5007311.9523812.3223441,2702225.5448
Table 3. Computational results for randomly generated instances from classes 2–7.
Table 3. Computational results for randomly generated instances from classes 2–7.
n | B | N-Fix JobsLaws Δ ( % ) Δ mid - p ( % ) Per OB ( π k , T ) Δ mid - p / Δ Δ max / Δ CPU-Time (s)
12345678910
Class 2
50101.2.31.0235982.4019251.0272.3465511,3957080,020781
100101.2.30.6083790.9955880.99481.6364611.6181330.047795
500101.2.30.2651690.4826310.99471.8200921.6300940.215172
1000101.2.30.1760920.2525250.99521.4340531.4270690.535256
5000101.2.30.1114180.149070.99521.337931.0896637.096339
10,000101.2.30.1171650.137940.99481.1773131.00461225.28328
Minimum0.1114180.137940.99471.1773131.0046120.020781
Average0.3836370.7366130.994941.62541.3999445.533104
Maximum1.0235982.4019250.99522.3465511.63009425.28328
Class 3
50311.2.30.6361630.6576191.1714291.0337271.0042460.047428
100311.2.31.7050781.7892221.2402381.0493491.0095680.066329
500311.2.30.3325470.3828981.2059521.1514121.1388690.249044
1000311.2.30.2868630.3732471.4008331.3011321.1017480.421837
5000311.2.30.2466090.3235081.3808331.3118251.1407282.51218
10,000311.2.30.260480.3387091.0985721.3003241.0958125.46782
Minimum0.2466090.3235081.0985721.0337271.0042460.047428
Average0.5779570.6442011.2496431.1912951.08182861.460773
Maximum1.7050781.7892221.4008331.3118251.1407285.46782
Class 4
503110.4678850.4973911.173691.0630641.0354120.043454
1003110.2158690.2266971.3172221.050161.0315640.067427
5003110.1284450.154531.4244441.2030831.179120.256617
10003110.1113040.1188821.3077381.0680771.0428520.50344
50003110.0769170.0855041.3990481.1116311.0460612.612428
10,0003110.0678360.0762211.5919051.1236061.1140054.407236
Minimum0.0678360.0762211.173691.050161.0315640.043454
Average0.1780430.1932041.3690081.103271.0748361.3151
Maximum0.4678850.4973911.5919051.2030831.179124.407236
Class 5
50321.2.31.3416191.5088281.2961951.1246321.0351820.049344
100321.2.30.7009550.8678861.2719761.2381491.0374720.070402
500321.2.30.1823780.2417351.0291.325461.2964140.255463
1000321.2.30.0980770.110731.4734511.1290061.1045370.509969
5000321.2.30.0745990.0844181.2044351.1316241.0562542.577595
10,000321.2.30.0642260.0747491.3591811.1638461.0426765.684847
Minimum0.0642260.0747491.0291.1246321.0351820.049344
Average0.4103090.4813911.2723731.1854531.0954221.524603
Maximum1.3416191.5088281.4734511.325461.2964145.684847
Class 6
50421.2.30.2540230.3995141.8189051.572751.5533950.058388
100421.2.30.2165410.2604341.8682781.2027041.038680.091854
500421.2.30.0819320.0984571.9985161.2016911.12920.365865
1000421.2.30.061450.0678791.9339841.1046221.0618660.713708
5000421.2.30.0509670.0603941.9364531.1849531.0487533.602502
10,000421.2.30.0453030.053782.3320081.1871011.0385617.426986
Minimum0.0453030.053781.8189051.1046221.0385610.058388
Average0.1183690.1567431.9813571.2423041.14507562.043217
Maximum0.2540230.3995142.3320081.572751.5533957.426986
Class 7
5022–41.2.34.7736186.7559180.2629461.4152621.3080450.039027
10022–41.2.33.9266124.9918430.2248771.2712851.1607230.059726
50022–61.2.33.8117944.6000170.2591611.2067851.1323530.185564
100022–81.2.33.594574.4598550.3379681.240721.089920.474514
500022–81.2.33.5852194.2979680.2610021.1988021.0313192.778732
10,00022–81.2.33.6077674.2755810.2993111.1851051.0130965.431212
Minimum3.5852194.2755810.2248771.1851051.0130960.039027
Average3.8832634.8968640.2742111.2529931.1225761.494796
Maximum4.7736186.7559180.3379681.4152621.3080455.431212

© 2018 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).
Back to TopTop