Single Machine Scheduling Problem with Interval Processing Times and Total Completion Time Objective

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.


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.

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 L i , p U i ], where p U i ≥ p L i > 0. The exact value p i ∈ [p L i , p U i ] 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 L i , p U i ]: . 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 L i ≤ p i ≤ p U i | ∑ C i using the three-field notation α|β|γ [13], where γ denotes the objective function.If scenario p ∈ T is fixed before scheduling, i.e., [p L i , p U i ] = [p i , p i ] for each job J i ∈ J , then the uncertain problem 1|p L i ≤ p i ≤ p U i | ∑ 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 L i ≤ p i ≤ p U i | ∑ 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 U v < p L w .
Since for the problem α|p L i ≤ p i ≤ p U i |γ, 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 γ k p − γ t p =: r(π k , p) is called the regret for permutation π k with the objective function γ equal to γ k p 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) γ t p : 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 L i ≤ p i ≤ p U i | ∑ 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 L i ≤ p i ≤ p U i | ∑ 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 L i ≤ p i ≤ p U i | ∑ 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 [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 Sections 3-6, we continue the investigation of the optimality box for the problem 1|p 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 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 L i ≤ p i ≤ p U i | ∑ C i were solved by Algorithm 3 with the average error equal to 0.735154%.

The Optimality Box
Let M denote a subset of the set N = {1, 2, . . ., n}.We define an optimality box for the job permutation Definition 2. The maximal (with respect to the inclusion) rectangular box OB(π 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 and the length u * k i − l * k i ≥ 0 indicated in Definition 2 is called an optimality segment for the job ] 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.[15], the notion of a block for the jobs J may be introduced for the problem 1|p

An Example of the Problem 1|p
Definition 3. A maximal set B r = {J r 1 , J r 2 , . . ., J r |Br | } ⊆ J of the jobs, for which the inequality 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 L i , p U i ] 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 .

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
Then, all jobs included in the block B 1 may be determined as follows: 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 U 1 = p U i 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 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
] 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: 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 L r < b L s .
Proof.For any two jobs J v ∈ B r and 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 L r < b L s .Using Definition 3, one can convince that the cores of any two blocks have no common point.Thus, the inequality b w ≤ 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 L v < b L u implies v < u.Due to Definition 3, each block B r = {J r 1 , J r 2 , . . ., J r |Br | } may include jobs of the following four types.If p L r i = b L r and p U r i = b U r , 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 L r i < b L r , we say that job J r i is a left job in the block B r .If p U r i > b U r , 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 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: 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(π the set B r is a singleton and so job J r 1 ∈ B r has the optimality segment [p L r 1 , p U r 1 ] with the length p U r 1 − p L r 1 ≥ 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: 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 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 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 L r u , p U r 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 L i ≤ p i ≤ p U i | ∑ 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 L i ≤ p i ≤ p U i | ∑ C i coincides with the optimality box for the same permutation for the problem 1| , 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| Step 1: Step 2:

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: where J (π k ) denotes the set of all jobs holds.Theorem 3 gives the sufficient and necessary condition for the smallest value of PerOB(π k , T), i.e., the equalities J (π k ) = ∅ and PerOB(π k , T) = 0 hold for each permutation π k ∈ S. A necessary and sufficient condition for the largest value of PerOB(π 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
Hence, the desired equalities , then the equality (3) is not possible for at least one job J k i ∈ B r .Therefore, the inequality PerOB(π k , T) < n holds for any permutation π k ∈ S.
The length of the relative perimeter PerOB(π 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 Proof.Since the equality B 1 = J holds, each permutation π k ∈ S looks as follows: Due to Lemma 2, only job J k 1 may have the optimality segment (this segment looks as follows: ) and only job J n may have the following optimality segment 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 PerOB(π 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: we should choose the job J k v such that the equality k s holds.Thus, to determine the largest value of PerOB(π 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 PerOB(π 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 PerOB(π 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 L i ≤ p i ≤ p U i | ∑ C i can be decomposed into the subproblem P 1 with the set of jobs J 1 := r k=1 B k and the subproblem P 2 with the set of jobs J 2 := m k=r+1 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 L v holds for each pair of jobs J u ∈ r k=1 B k and J v ∈ m k=r+1 B k .Due to Theorem 2, any job J u ∈ r k=1 B k dominates any job J v ∈ m k=r+1 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 L i ≤ p i ≤ p U i | ∑ 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 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 PerOB(π k , T) for the special case of the problem 1|p 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 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  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 g f , 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 PerOB(π (g) , T ( f ) ) for each subproblem P g f , 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: PerOB(π ( f * ) , T ( f ) ) = max g∈{1,2,...,|B(J j f )|} PerOB(π (g) , T ( f ) ).
Due to Lemma 4, the optimality box OB(π k , T) with the largest relative perimeter for the original problem 1|p L i ≤ p i ≤ p U i | ∑ 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: ).The permutation π k with the largest length of the relative perimeter of the optimality box OB(π k , T) for the problem 1|p L i ≤ p i ≤ p U i | ∑ 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 L v > p U i or the inequality p U v < p L i holds for each job 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).

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 L i ≤ p i ≤ p U i | ∑ 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 L i , p U i ] for the jobs J i ∈ J .Output: The permutation π k ∈ S with the largest relative perimeter PerOB(π k , T). Step 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 = ∪ r k=1 B k and subproblem P 2 with the set of jobs J 2 = ∪ m k=r+1 B k using Lemma 4; set Step 8: Construct the permutation π s(i) with the largest relative perimeter PerOB(π s(i) , T) using Procedure 3 described in the proof of Theorem 5 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 PerOB(π 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 PerOB(π 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 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 PerOB(π k , T) STOP.

Procedure 5 for the Problem 1|p
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 L i ≤ p i ≤ p U i | ∑ C i with the largest value of PerOB(π 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 0 m ), where B 0 m denotes the following set of blocks: {B 1 , B 2 , . . ., B m } =: B 0 m .Moreover, the condition of Theorem 6 does hold for the set B = B 0 m of the blocks, i.e., there is a block B r ∈ B 0 m containing more than one non-fixed jobs.For the problem 1|p L i ≤ p i ≤ p U i | ∑ C i with J = {J 1 , J 2 , . . ., J n } = J (B 0 m ), one can calculate the following tight upper bound Per max on the length of the relative perimeter PerOB(π k , T) of the optimality box 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 PerOB(π k , T) holds, since the relative optimality segment 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 2m.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 t k 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 | 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 l k ]), the penalty φ u determined in ( 6) is calculated, which is equal to the difference between the lengths of the maximal possible relative perimeter Per max 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] ): where Per u max 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 ), 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.

The Application of Procedure 5 to the Small Example
Table 1 presents input data for the example of the problem 1|p L i ≤ p i ≤ p U i | ∑ C i described in Section 3.1.The jobs J 4 , J 5 and J 7 are non-fixed: 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 Per max = 4 × 2 = 8 due to the upper bound on the relative perimeter PerOB(π k , T) given in (5).

An Approximate Solution to the Problem 1|p
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 L i ≤ p i ≤ p U i | ∑ 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 L i ≤ p i ≤ p U i | ∑ C i , one can estimate how the value of ∑ n i=1 C i (π k , p) with a vector p ∈ T may be close to the optimal value of ∑ n i=1 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: A value of the error function F(π k , T) characterizes how the objective function value of ∑ n i=1 C i (π k , p * ) for the permutation π k may be close to the objective function value of ∑ n i=1 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 which has to be minimized for a good approximate solution π k to the uncertain problem 1|p The formula ( 7) is based on the cumulative property of the objective function > 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 ∑ n i=1 C i (π t , T) for the permutation π k .If the equality PerOB(π k , T) = 0 holds, the error function F(π k , T) has the maximal possible value determined as follows: 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 PerOB(π k , T) = n holds, the error function F(π k , T) has the smallest value equal to 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.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 PerOB(π 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  In Section 6, we describe the results of the computational experiments on applying Algorithm 3 to the randomly generated problems 1|p L i ≤ p i ≤ p U i | ∑ C i .

Computational Results
For the benchmark instances 1|p L i ≤ p i ≤ p U i | ∑ C i , where there are no properties of the randomly generated jobs J , which make the problem harder, the mid-point permutation π mid−p = π e ∈ S, where all jobs J i ∈ J are ordered according to the increasing of the mid-points , 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 π mid−p and the permutation π max 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 L i < p U i hold for all jobs J i ∈ J .Table 2 presents computational results for randomly generated instances of the problem 1|p L i ≤ p i ≤ p U i | ∑ 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 L i , p U i ] was generated using a uniform distribution in the range [1,100].The lower bound p L i of the possible processing time p i was determined using the equality , 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 L i < p U i 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 • 100% of the value γ k p * of the objective function γ = ∑ n i=1 C i was for the permutation π k with the minimal value of F(π k , T) with respect to the actually optimal objective function value γ t p * 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 γ k p * 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 ∆ mid−p of the value γ m p * of the objective function ∑ C i for the permutation π mid−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 ∆ max of the value of the objective function ∑ C i for the permutation π max 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 ∆ mid−p obtained for the mid-point permutations π mid−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 ∆ mid−p /∆.Column 7 presents the relation ∆ max /∆.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 γ k p * , which are smaller than those obtained for the permutations π mid−p and for the permutations π max .The smallest errors, average errors, largest errors for the tested series of the instances are presented in the last rows of Table 2.
Each instance in class 2 has fixed jobs J i ∈ J with rather closed centers (p L i + p U i )/2 and large difference between segment lengths p U i − p L i .Each instance in class 3 or in class 4 has a single non-fixed job J v , whose bounds are determined as follows: p 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 ∆, ∆ mid−p , ∆ mid−p ∆ and ∆ max ∆ 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.

Concluding Remarks
The uncertain problem 1|p L i ≤ p i ≤ p U i | ∑ 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 Sections 2-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 L i ≤ p i ≤ p U i | ∑ 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 L i ≤ p i ≤ p U i | ∑ 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 ∆ mid−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 ∆ max 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 for the obtained errors for all instances of classes 1-7 was equal to 1.33235.The average relation ∆ max ∆ for the obtained errors for all instances of classes 1-7 was equal to 1.1133116.
there exists a permutation π k ∈ S, for which the equality PerOB(π 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 π Next, we show how to construct a permutation π k ∈ S with the largest value of the relative perimeter PerOB(π 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 PerOB(π k , T) among all permutations S.
r k=1 B k and the set of jobs m k=r+1 B k are considered separately one from another.

Theorem 6 .
The proof of Theorem 6 is based on Procedure 4. 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 PerOB(π k , T) is constructed in O(n log n) time.
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) ).

1 : 4 :
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 PerOB(π 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 Index the blocks B = {B 1 .B 2 , . . ., B m } according to increasing left bounds of their cores (Lemma 3) Step 5:

Theorem 7 .Theorem 8 .
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. 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 PerOB(π k , T).

3 Input: 2 holds STOP. Step 2 :
whose optimality box OB(π k , T) provides the minimal value of the error function F(π k , T) among all permutations S. Algorithm Segments [p L i , p U i ] 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) IF the condition of Theorem 4 holds THEN using Procedure 2+F(π k , T) construct the permutation π k ∈ S such that both equalities PerOB(π 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:

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 = ∪ r k=1 B k and subproblem P 2 with the set of jobs J 2 = ∪ m k=r+1 B k using Lemma 4; setP = 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 ELSEStep 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 11Step 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 1IF 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.

Table 1 .
Input data for the problem 1|pL i ≤ p i ≤ p U i | ∑ C i .
(the cores of the blocks B 1 , B 2 , B 3 and B 4 are dashed).
Figure 1.The segments [p Li , p U i ] given for the feasible processing times of the jobs J i ∈ J = {J 1 , J 2 , . . ., J 10 } 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.
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 − 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 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).
Hereafter, δ denotes the maximal relative error of the processing times p i due to the given segments [p L i , p U i ].The upper bound p U i was determined using the equality p U i = C • (1 + δ 100 ).Then, for each job J i ∈ J , the point p i was generated using a uniform distribution in the range [p L i , p U i ].In order to generate instances, where all jobs J belong to a single block, the segments [p L i , p U i ] of the possible processing times were modified as follows:[ p L i , p U i ] = [p L i + p − p i , p U i + p − p i ],where p = max n i=1 p i .Since the inclusion p ∈ [ p L i , p U i ] holds, each constructed instance contains a single block, |B| = 1.The maximum absolute error of the uncertain processing times p

Table 2 .
Computational results for randomly generated instances with a single block (class 1).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|pL i ≤ p i ≤ p U i | ∑ 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 L i and the upper bound p U i on the feasible values of p i ∈ R 1 i ] for the processing times of |B i | jobs from all blocks B

Table 3 .
Computational results for randomly generated instances from classes 2-7.