Next Article in Journal
Planning the Schedule for the Disposal of the Spent Nuclear Fuel with Interactive Multiobjective Optimization
Next Article in Special Issue
Linking Scheduling Criteria to Shop Floor Performance in Permutation Flowshops
Previous Article in Journal
Target Image Mask Correction Based on Skeleton Divergence
Previous Article in Special Issue
Modeling and Solving Scheduling Problem with m Uniform Parallel Machines Subject to Unavailability Constraints

Algorithms 2019, 12(12), 250; https://doi.org/10.3390/a12120250

Article
Some Results on Shop Scheduling with S-Precedence Constraints among Job Tasks
1
Dipartimento di Ingegneria dell’Informazione e Scienze Matematiche, Università di Siena, SI 53100 Siena, Italy
2
Dipartimento di Ingegneria e Scienze dell’Informazione e Matematica, Università di L’Aquila, AQ 67100 L’Aquila, Italy
*
Author to whom correspondence should be addressed.
Received: 9 October 2019 / Accepted: 18 November 2019 / Published: 25 November 2019

Abstract

:
We address some special cases of job shop and flow shop scheduling problems with s-precedence constraints. Unlike the classical setting, in which precedence constraints among the tasks of a job are finish–start, here the task of a job cannot start before the task preceding it has started. We give polynomial exact algorithms for the following problems: a two-machine job shop with two jobs when recirculation is allowed (i.e., jobs can visit the same machine many times), a two-machine flow shop, and an m-machine flow shop with two jobs. We also point out some special cases whose complexity status is open.
Keywords:
job shop; flow shop; s-precedence constraints; exact algorithms; complexity

1. Introduction

This paper addresses a variant of classical shop scheduling models. While, in classical job shop or flow shop (as well as in the large majority of scheduling problems with precedence constraints), the task of a job cannot start before the previous task of the same job has finished, we address a situation in which each task of a job cannot start before the previous task of the same job has started. These types of constraints are known in the literature as s-precedence constraints. Scheduling problems with s-precedence constraints have been introduced by Kim and Posner [1] in the case of parallel machines. They showed that makespan minimization is NP-hard, and developed a heuristic procedure deriving tight worst-case bounds on the relative error. Kim, Sung, and Lee [2] performed a similar analysis when the objective was the minimization of total completion time of the tasks, while Kim [3] extended the analysis to uniform machines. Tamir [4] analyzed a parallel-machine problem in which traditional finish–start precedence constraints coexisted with s-precedence constraints (that she renamed selfish precedence constraints, giving an enjoyable dramatized motivation of the model), and established various worst-case bounds for classical dispatching rules which refer to specific structures of precedence constraints. Indeed, s-precedence constraints also arise in project management, called start–start precedence constraints (Demeulemeester and Herroelen [5]), as a result of the elaboration of a work breakdown structure (WBS) and of the coordination among different operational units. To our knowledge, none has addressed job shop and flow shop problems with s-precedence constraints so far.
The problem can be formally introduced as follows. We are given a set of n h J 1 , J 2 , , J n , to be processed on a shop with m machines denoted as M 1 , , M m . Each job J k consists of a totally ordered set of tasks, J k = { O 1 k , O 2 k , , O n k k } , k = 1 , , n . Task O i k requires processing time p i k on a given machine M ( O i k ) , i = 1 , , n k . Tasks cannot be preempted. Task O i k can only start after task O i 1 k is started; i.e., there is an s-precedence constraint between tasks O i 1 k and O i k , for all k = 1 , , n , i = 2 , , n i . A schedule is an assignment of starting times to all tasks so that at any time each machine processes at most one task and all s-precedence constraints are satisfied. The problem is to find a feasible schedule that minimizes makespan.
We characterize the complexity of special cases of the problem, considering a fixed number of jobs and machines. Shop problems with few jobs occur when modeling synchronization and conflicts among processes share common resources. Examples of this situation include scheduling robot moves in flexible robotic cells (Agnetis et al. [6]), aircraft scheduling during taxiing at an airport so that no aircraft collides (Avella et al. [7]), or, in container terminals, the synchronization of crane gantry movements once transportation tasks have been assigned (Briskorn and Angeloudis [8]).
The structure of the paper is as follows. In Section 2 we consider the job shop scenario, and give a polynomial time algorithm for the problem in which n = 2 , m = 2 , and each job can visit the machines several times (that is, recirculation [9] is allowed). In Section 3 we focus on the flow shop scenario. We show that the two-machine flow shop can be solved in linear time and we give a polynomial time algorithm for the m-machine problem with two jobs. In Section 4 we briefly discuss cases with n > 2 and point out open problems.

2. The Job Shop with Two Jobs and Two Machines

In this section we describe a polynomial algorithm for the job shop problem with two jobs and two machines; i.e., J 2 | n = 2 , s p r e c | C max . For notation simplicity, in this section we denote the two jobs as A and B, consisting of the sequence of tasks, A = { A 1 , A 2 , , A n A } and B = { B 1 , B 2 , , B n B } , respectively. Task A i ( B h ) requires processing time p i A ( p h B ) on machine M ( A i ) ( M ( B h ) ).
Obviously, if two consecutive tasks of the same job, say, A i and A i + 1 , require the same machine, then A i + 1 has to wait for the completion of A i , but if the machines required by the two operations are different, i.e., M ( A i + 1 ) M ( A i ) , then A i + 1 can start even if A i has not completed yet. So, unlike the classical job shop setting in which precedence relations are finish-start, in our model it may actually happen that A i + 1 even completes before A i (the same of course applies to job B).
Given a partial schedule, the first unscheduled tasks of the two jobs will be referred to as the available tasks. Suppose now that one of the two machines, say M , has just completed a task, while the other machine, say M , is still busy. If both the available tasks require M , we say that machine M is blocked and this certainly results in idle time on M .
We let A [ i ] and B [ h ] denote the first i tasks of A and the first h tasks of B; i.e., A [ i ] = { A 1 , A 2 , , A i } and B [ h ] = { B 1 , B 2 , , B h } .
Given A and B, consider any two task subsequences X A and Y B . We want to characterize the schedules of X Y such that each task starts right after the previous task on the same machine has completed. More formally, a schedule of X Y is a no-idle subschedule (NIS) if, across the span of such a subschedule, the only machine idle time occurs, on one machine, after all the tasks of X Y have started. When X = A [ i ] and Y = B [ h ] , for some 1 i n A and 1 h n B , then we say that the NIS is an initial no-idle subschedule (INIS).
Consider Figure 1 and the task set A [ 2 ] B [ 2 ] . The subschedule in Figure 1a is not an INIS for A [ 2 ] B [ 2 ] , since on M 1 there is idle time before B 2 starts. On the contrary, in the case depicted in Figure 1b, the subschedule of A [ 2 ] B [ 2 ] is an INIS. Note that if we restrict our attention to the task set A [ 2 ] B [ 1 ] , then the subschedule in Figure 1a is an INIS.

2.1. Generating Initial No-Idle Subschedules

We denote by A [ i , M j ] and B [ h , M j ] , the subset of tasks of A [ i ] and B [ h ] respectively, requiring machine M j , j = 1 , 2 ; i.e.,
A [ i , M j ] = { A r : r i , M ( A r ) = M j } j = 1 , 2 ,
B [ h , M j ] = { B q : q h , M ( B q ) = M j } j = 1 , 2 .
We also let P ( A [ i , M j ] ) and P ( B [ h , M j ] ) indicate the total processing time of tasks in A [ i , M j ] and B [ h , M j ] ; i.e.,
P ( A [ i , M j ] ) = r A [ i , M j ] p r A ,
P ( B [ h , M j ] ) = q B [ h , M j ] p q B .
If an INIS of tasks A [ i ] B [ h ] exists, its makespan is given by
max { P ( A [ i , M 1 ] ) + P ( B [ h , M 1 ] ) , P ( A [ i , M 2 ] ) + P ( B [ h , M 2 ] ) } .
Proposition 1.
In any optimal schedule, there are indices i and h such that the subschedule involving tasks A [ i ] B [ h ] is an INIS.
In fact, given an optimal schedule, consider the subschedule of the tasks scheduled on the two machines from time 0 to the end of the first idle interval of the schedule, assuming, e.g., that such an idle interval occurs on M 1 . If the subschedule is not an INIS, we can iteratively remove the last task scheduled on M 2 in the subschedule, until the definition of INIS is met.
In view of Proposition 1, we are only interested in schedules in which the initial part is an INIS. However, not all initial no-idle subschedules are candidates to be the initial part of an optimal schedule.
We first address the following question. Can we determine all operation pairs ( i , h ) such that an INIS of A [ i ] B [ h ] exists? We show next that this question can be answered in polynomial time.
The idea is to build the no-idle partial schedules from the beginning of the schedule onward. To this aim, let us define an unweighted graph G, which we call initial no-idle graph. Nodes of G are denoted as ( i , h ) , representing a NIS of A [ i ] B [ h ] (for shortness, we use ( i , h ) also to denote the corresponding INIS). If the schedule obtained appending B h + 1 to schedule ( i , h ) is still an INIS, we insert node ( i , h + 1 ) and an arc from ( i , h ) to ( i , h + 1 ) in G. Symmetrically, if the schedule obtained appending A i + 1 to ( i , h ) is an INIS, we insert ( i + 1 , h ) and an arc from ( i , h ) to ( i + 1 , h ) in G.
As illustrated later on (cases ( i ) ( i v ) below), while building the graph G, we can also determine whether or not a certain INIS can be the initial part of an optimal schedule. If it can, we call it a target node.
Consider any node ( i , h ) in G, and the machine completing soonest in the INIS. Ties can be broken arbitrarily, but to fix ideas, suppose that M 2 is still busy when M 1 completes. (Note that, since there is no idle time, M 1 completes at time P ( A [ i , M 1 ] ) + P ( B [ h , M 1 ] ) .) If i < n A and h < n B , the two available tasks are A i + 1 and B h + 1 , and four cases can occur.
( i )
M ( A i + 1 ) = M ( B h + 1 ) = M 2 . In this case, M 1 is necessarily idle until M 2 completes (Figure 2a). Hence, there is no way to continue an INIS, and therefore node ( i , h ) has no outgoing arcs. In this case, ( i , h ) is a target node.
( i i )
M ( A i + 1 ) = M 1 and M ( B h + 1 ) = M 2 . In this case, when A i completes, the only way to continue an INIS is to start task A i + 1 on M 1 (Figure 2b). Thus we generate node ( i + 1 , h ) and the arc from ( i , h ) to ( i + 1 , h ) , which is the only outgoing arc of ( i , h ) . In this case as well, ( i , h ) is a target node.
( i i i )
M ( A i + 1 ) = M 2 and M ( B h + 1 ) = M 1 . A symmetrical discussion to the previous case holds; i.e., the only way to continue an INIS is to start task B h + 1 on M 1 (Figure 2c), so we generate node ( i , h + 1 ) and the arc from ( i , h ) to ( i , h + 1 ) , which is the only outgoing arc of ( i , h ) . In this case also, ( i , h ) is a target node.
( i v )
M ( A i + 1 ) = M ( B h + 1 ) = M 1 . In this case, the INIS can be continued in two possible ways; i.e., scheduling either A i + 1 or B h + 1 on M 1 (Figure 2b,c respectively). Therefore, ( i , h ) has two outgoing arcs, pointing towards nodes ( i + 1 , h ) and ( i , h + 1 ) , respectively. However, in this case ( i , h ) is not a target node, since there is no point in keeping M 1 idle until the completion of M 2 .
Clearly, if M 2 completes before M 1 , in the four above cases the roles of M 1 and M 2 are exchanged. If either i = n A or h = n B , the above cases simplify as follows, where we assume that h = n B ; i.e., job B is finished. (A symmetric discussion holds in i = n A .)
( v )
M ( A i + 1 ) = M 1 . In this case, we can continue an INIS starting task A i + 1 on M 1 . Thus we generate node ( i + 1 , h ) and the arc from ( i , h ) to ( i + 1 , h ) , which is the only outgoing arc of ( i , h ) . Node ( i , h ) is a target node.
( v i )
M ( A i + 1 ) = M 2 . In this case, M 1 is necessarily idle until M 2 completes. Hence, there is no way to continue an INIS, and therefore node ( i , h ) has no outgoing arcs. In this case, ( i , h ) is a target node.
Again, the roles of the two machines are exchanged if M 2 frees up before M 1 in the partial schedule.
In conclusion, the question of whether a NIS exists for the task set A [ i ] B [ h ] is equivalent to asking whether node ( i , h ) can be reached from the dummy initial node ( 0 , 0 ) on G.
A few words on complexity. Clearly, G has O ( n A n B ) nodes, and each node has at most two outgoing arcs. The graph G can be built very efficiently. In fact, for each node ( i , h ) , it can be checked in constant time, which condition holds among ( i ) ( i v ) (or ( v ) ( v i ) when one of the jobs is over), and hence whether or not it is a target node.

2.2. Minimizing the Makespan

Now we can address the main question. How to schedule the tasks on the two machines so that the overall makespan is minimized. The key idea here is that any active schedule can be seen as the juxtaposition of no-idle subschedules. In fact, suppose that after processing a certain task A i , one machine stays idle until the other machine completes task B h . It is important to observe that this may happen for one of two reasons:
  • When a machine completes, it is blocked because both available tasks require the other machine;
  • When a machine completes, there is one task the machine can process, but it might be profitable to wait for the other machine to free up another task.
Note that in both of these two cases ( i , h ) is a target node of G. On the contrary, if a machine completes a task while the other machine is still busy, and both available tasks require that machine (i.e., ( i , h ) is not a target node of G), with no loss of generality we can assume that the machine will immediately start one of them, since otherwise the schedule might turn out non-active (there is no point in waiting for the other machine to complete its task).
If t denotes the makespan of an INIS, the schedule after t is completely independent from the schedule before t. In other words, the optimal solution from t onward is the optimal solution of a problem in which t is indeed time 0, and the two jobs are A \ A [ i ] and B \ B [ h ] . Hence, to address the overall problem, the idea is to build another, higher-level graph in which the arcs specify portions of the overall schedule.
Suppose that ( i , h ) is a target node of graph G, and consider the task sets A \ A [ i ] and B \ B [ h ] . We can build a new no-idle graph on these sets, and call it G ( i , h ) . (Correspondingly, the graph previously denoted as G can be renamed G ( 0 , 0 ) .) Suppose that ( r , q ) is a target node in graph G ( i , h ) . This means that the tasks of the set { A i + 1 , A i + 2 , , A r } { B h + 1 , B h + 2 , , B q } form a NIS, that we denote by [ ( i + 1 , h + 1 ) ( r , q ) ] . It is convenient to extend the previous notation, letting A [ i + 1 , r , M j ] denote the set of tasks of A [ i + 1 , r ] that require machine M j , and analogously we let B [ h + 1 , q , M j ] be the set of tasks of B [ h + 1 , q ] that require M j . Their total processing times are denoted as P ( A [ i + 1 , r , M j ] ) and P ( B [ h + 1 , q , M j ] ) . (The set previously denoted as A [ i , M j ] should now be written A [ 0 , i , M j ] .)
We next introduce the (weighted) graph G as follows. As in G, nodes denote task pairs ( i , h ) . There is an arc [ ( i , h ) , ( r , q ) ] if ( r , q ) is a target node in the graph G ( i , h ) ; i.e., if the NIS [ ( i + 1 , h + 1 ) ( r , q ) ] exists. Such an arc [ ( i , h ) , ( r , q ) ] is weighted by the length of the corresponding NIS; i.e.,
max { P ( A [ i + 1 , r , M 1 ] ) + P ( B [ h + 1 , q , M 1 ] ) , P ( A [ i + 1 , r , M 2 ] ) + P ( B [ h + 1 , q , M 2 ] ) } .
Moreover, G contains a (dummy) initial node ( 0 , 0 ) while the final node is ( n A , n B ) . At this point the reader should have no difficulty in figuring out that the following theorem holds.
Theorem 1.
Given an instance of J 2 | n = 2 , s p r e c | C max , the optimal schedule corresponds to the shortest path from ( 0 , 0 ) to ( n A , n B ) on G , and its weight gives the minimum makespan.
Now, let us discuss complexity issues. The graph G can indeed be generated starting from ( 0 , 0 ) , and moving schedules forward. From each node ( i , h ) of G , we can generate the corresponding no-idle graph G ( i , h ) , and add to G all target nodes of G ( i , h ) . We then connect node ( i , h ) in G to each of these nodes, weighing the arc with the corresponding length of the NIS. If a target node was already present in G , we only add the corresponding new arc. Complexity analysis is, therefore, quite simple. There are O ( n A n B ) nodes in G . Each of these nodes has a number of outgoing arcs, whose weight can be computed in O ( n A n B ) . Clearly, finding the shortest path on G is not the bottleneck step, and therefore, the following result holds.
Theorem 2.
J 2 | n = 2 , s p r e c | C max can be solved in O ( n A 2 n B 2 ) .
Example 1.
Consider the following instance, in which job A has four tasks and job B two tasks.
job ine A B 1 5 , M 1 4 , M 2 | 2 1 , M 1 7 , M 2 | 3 4 , M 2 - | 4 6 , M 1 -
Figure 3a depicts the graph G ( 0 , 0 ) , in which all nodes are target nodes. Figure 3b shows the INIS [ ( 0 , 0 ) ( 2 , 2 ) ] . At the end of this INIS, machine M 1 is blocked, since the next task of A requires M 2 and job B is already finished. Notice that [ ( 0 , 0 ) ( 2 , 2 ) ] is the longest INIS which can be built, but the optimal solution does not contain it. Figure 4a shows the best schedule which can be attained when the INIS [ ( 0 , 0 ) ( 2 , 2 ) ] , having makespan 17. Figure 4b shows the optimal schedule, having makespan 16. The optimal schedule consists of two no-idle subschedules; namely, the INIS [ ( 0 , 0 ) ( 1 , 1 ) ] (containing tasks A 1 and B 1 and corresponding to arc [ ( 0 , 0 ) , ( 1 , 1 ) ] on G ), and the NIS [ ( 2 , 2 ) ( 4 , 2 ) ] (containing tasks A 2 , A 3 , A 4 and B 2 and corresponding to arc [ ( 1 , 1 ) , ( 4 , 2 ) ] on G ). For illustrative purposes, Figure 5 shows the graph G ( 1 , 1 ) . Notice that in such a graph, (2,1) is not a target node.

3. Flow Shop

In this section we consider the flow shop problem, i.e., F | s p r e c | C max , in which the job set J contains n jobs, and job J k requires processing time p j k on machine M j (here we use index j for both tasks and machines, as there is exactly one task per machine). While in the classical problem F | | C max a job cannot start on machine M j before it is completed on M j 1 , in F m | s p r e c | C max , a job can start on machine M j as soon as it is started on M j 1 .

3.1. Two-Machine Flow Shop ( F 2 | s p r e c | C max )

We next consider the two-machine flow shop problem, so p 1 k and p 2 k denote the processing times of job J k on M 1 and M 2 respectively, k = 1 , , n . Note that, as in the classical F 2 | | C max , with no loss of generality we can assume that in any feasible schedule the machine M 1 processes all the jobs consecutively with no idle time between them. We next show that problem F 2 | s p r e c | C max can be solved in linear time.
Proposition 2.
Given an instance of F 2 | s p r e c | C max , there always exists a schedule σ * having makespan max { k = 1 n p 1 k , k = 1 n p 2 k } , which is therefore optimal.
Proof. 
Given an instance of F 2 | s p r e c | C max , partition the jobs into two sets, J and J , such that J = { J k | p 1 k p 2 k } and J = J \ J . Then, build σ * by scheduling, on both machines, first all jobs of J in arbitrary order, and then all jobs of J , also in arbitrary order. If we let C ( 1 ) and C ( 2 ) denote the completion time of the last job of J on M 1 and M 2 respectively, one has C ( 1 ) < C ( 2 ) . From the definition of J , one gets that up to C ( 2 ) , no idle time occurs on M 2 . From then on, all jobs of J are scheduled, and two cases may occur. ( i ) No idle time ever occurs on M 2 , in which case the makespan equals max { k = 1 n p 1 k , k = 1 n p 2 k } . ( i i ) Some idle time occurs on M 2 . Consider the first time that M 2 is idle and M 1 is still processing a job J k . Upon completion of J k , the two machines will simultaneously start the next job, say, J k ¯ , but since J k ¯ J , M 1 will still be processing it while M 2 returns idle. Since all remaining jobs belong to J , this will happen for each job until the end of the schedule. In particular, when the last job is scheduled, again, M 2 completes first, so in conclusion, the makespan of σ * is k = 1 n p 1 k . ☐
The above proof contains the solution algorithm. For each job J k , put it into J if p 1 k p 2 k and in J otherwise. Then, schedule all jobs of J followed by all jobs of J (in any order). Since establishing whether a job belongs to J or J can be done in constant time, and since jobs can be sequenced in arbitrary order within each set, we can conclude with the following result.
Theorem 3.
F 2 | s p r e c | C max can be solved in O ( n ) .
While F 2 | s p r e c | C max appears even simpler than the classical F 2 | | C max , one may wonder whether other simplifications occur for m > 2 . While the complexity status of F m | s p r e c | C max is open, we point out a difference between F m | | C max and F m | s p r e c | C max , which may suggest that the problem with s-precedence constraints is not necessarily easier than the classical counterpart.
It is well known [10] that in F m | | C max there always exists an optimal schedule in which the job sequences on M 1 and M 2 are identical, and the same holds for machines M m 1 and M m . (As a consequence, for m 3 the optimal schedule is a permutation schedule.) This is no more true in F m | s p r e c | C max , even with only two jobs.
Example 2.
Consider an instance with three machines and two jobs, A and B:
j ine A B ine 1 4 , M 1 10 , M 1 | 2 6 , M 2 4 , M 2 | 3 1 , M 3 9 , M 3
Scheduling the jobs in the order AB on all three machines, one gets C m a x = 15 , and the makespan is attained on machine M 3 (see Figure 6a). If they are scheduled in the order BA on all three machines, C m a x = 16 , and in this case the value of the makespan is attained on M 2 (Figure 6b). If jobs are scheduled in the order AB on M 1 and BA on M 2 and M 3 , then C m a x = 14 (all three machines complete at the same time, Figure 6c), and this is the optimal schedule.

3.2. Flow Shop with Two Jobs and m Machines ( F m | n = 2 , s p r e c | C max )

In what follows we give an Algorithm 1 that solves F m | n = 2 , s p r e c | C m a x . Again we denote the two jobs with A and B, and by p j A and p j B the processing time of jobs A and B on machine M j , j = 1 , , m , respectively. Notice that a schedule is fully specified by the order of the two jobs on each machine, either AB or BA. In what follows, for a given schedule and a given machine, we call leader the job scheduled first and follower the other job. So if, on a given machine, the jobs are sequenced in the order AB, then, on that machine, A is the leader and B is the follower.
Algorithm 1 For finding a schedule with C m a x K if it exists.
1:
Initialize F A ( 0 ) = F B ( 0 ) = 0
2:
for u = 1 , , m do
3:
for v = 1 , , m do
4:
  Compute L A ( u , v ) , L B ( u , v ) , S A ( u , v ) and S B ( u , v ) via (1), (2), (3) and (4) respectively; 
5:
end for 
6:
end for 
7:
for v = 1 , , m do
8:
 Compute F A ( v ) and F B ( v ) via (5) and (6); 
9:
end for 
10:
if F A ( m ) < + or F B ( m ) < + then
11:
C max K
12:
else
13:
C max > K
14:
end if
Given any feasible schedule, we can associate with it a decomposition of the m machines into blocks, each consisting of a maximal set of consecutive machines in which the two jobs are scheduled in the same order. We denote the block consisting of machines M u , M u + 1 , , M v as < M u , M v > (see Figure 7). In a block, due to the s-precedence constraints, all the tasks of the leader job start at the same time. Given a block < M u , M v > , we can compute a number of quantities. (Assume for the moment that v < m .) If, in < M u , M v > , A is the leader, then we call leader span the length of the longest A-task in the block, and denote it with L A ( u , v ) :
L A ( u , v ) = max u j v { p j A } ,
and similarly, if B is the leader, the leader span is given by:
L B ( u , v ) = max u j v { p j B } .
Notice that, due to the definition of block, in the block that follows < M u , M v > , the roles of leader and follower are exchanged. Hence, the time at which the leader completes its longest task in < M u , M v > is also the start time of the other job’s tasks in the next block.
Given a block < M u , M v > , suppose again that A is the leader. We let S A ( u , v ) indicate the span of block < M u , M v > ; i.e., the difference between the maximum completion time of a B-task and the start time of all A-tasks in < M u , M v > . This is given by:
S A ( u , v ) = max u j v { max u h j { p h A } + p j B } ,
and exchanging the roles of leader and follower in < M u , M v > , we get
S B ( u , v ) = max u j v { max u h j { p h B } + p j A } .
Notice that trivial lower and upper bounds for the minimum makespan are given by
L B = max { max 1 j m { p j A } , max 1 j m { p j B } }
and
U B = max 1 j m { p j A } + max 1 j m { p j B }
respectively. In what follows we address the problem of determining a schedule having a makespan not larger than K, or prove that it does not exist. Assuming that all processing time values are integers, a binary search over the interval [ L B , U B ] allows one to establish the value of the minimum makespan.
As we already observed, a relevant difference between F m | | C m a x and F m | s p r e c | C m a x is that, in a feasible schedule for F m | s p r e c | C m a x , the value of C m a x may not be attained on the last machine, but rather on any machine. This fact requires carefully handling by the algorithm.
Let F A ( v ) be the minimum sum of leader spans of all blocks from M 1 to M v , when A is the leader of the last block (i.e., the block including M v ). Similarly, F B ( v ) is the same when B is the leader of the last block. In order to write a functional equation for F A ( v ) and F B ( v ) , we introduce the notation δ ( x ) = 0 if x 0 and δ ( x ) = + if x > 0 .
Hence, we write
F A ( v ) = min 0 u v { F B ( u ) + L A ( u + 1 , v ) + δ ( F B ( u ) + S A ( u + 1 , v ) K ) } .
The first terms accounts for the fact that in the previous block the leader is B, while the rightmost term ( δ ( · ) ) rules out solutions in which the sum of the start time of the last block and the span of the block itself exceeds K. Symmetrically, one has:
F B ( v ) = min 0 u v { F A ( u ) + L B ( u + 1 , v ) + δ ( F A ( u ) + S B ( u + 1 , v ) K ) } .
Expressions (5) and (6) are computed for v = 1 , , m . If at least one of the values F A ( m ) and F B ( m ) has a finite value, a schedule of makespan not exceeding K exists. The values of machine index for which each minimum in (5) and (6) is attained define the blocks of the schedule, which can, therefore, be easily backtracked.
Equations (5) and (6) must be initialized, simply letting F A ( 0 ) = F B ( 0 ) = 0 .
Notice that in general one cannot infer the value of the minimum makespan schedule directly from this procedure. If the minimum in the computation of F A ( m ) has been attained for, say, machine M u , it does not imply that F B ( u ) + S A ( u + 1 , m ) is indeed the minimum makespan. This is because the overall makespan may be due to a previous machine, and the algorithm has no control on this aspect. For instance, in the sample schedule of Figure 7 the makespan is attained on machine M 6 . However, its actual value has no relevance, so long as it does not exceed K, since it does not affect the values F A ( v ) and F B ( v ) subsequently computed.
Concerning complexity, each computation of (5) and (6) requires O ( m ) comparisons. Since the whole procedure is repeated at each step of a binary search over [ L B , U B ] , the following result holds.
Theorem 4.
Problem F m | n = 2 , s p r e c | C m a x can be solved in O ( m 2 l o g ( U B L B ) ) .

4. Further Research

In this paper we established some preliminary complexity results for perhaps the most basic cases of shop problems with s-precedence constraints. Here, we briefly elaborate on possible research directions.
  • Job shop problem with three jobs. The job shop problem with more than two jobs is NP-hard. This is a direct consequence of the fact that J | s p r e c | C m a x can be viewed as a generalization of J | | C m a x , which is NP-hard with three jobs [11].
Theorem 5.
J | n = 3 , s p r e c | C m a x is NP-hard.
Proof. 
Consider an instance I of J | n = 3 | C m a x , in which O i k denotes the i-th task of job J k in I, having processing time p i k on machine M ( O i k ) .
We can define an instance I of J | n = 3 , s p r e c | C m a x with the same number of machines. The three jobs of I are obtained replacing each task O i k of I with a sequence of two tasks O i k and O i k , in which O i k precedes O i k , O i k has length p i k and requires machine M ( O i k ) , while O i k has sufficiently small length ϵ > 0 and also requires machine M ( O i k ) . As a consequence, in J | s p r e c | C m a x , the task O i + 1 k cannot start before O i k is started, but since M ( O i k ) = M ( O i k ) = M ( O i k ) , this can only occur after O i k is finished. So, for sufficiently small ϵ , a feasible schedule for I having makespan K + m ϵ exists if and only if a feasible schedule for I exists having makespan K . ☐
Notice that the above reduction cannot be applied to F | n = 3 , s p r e c | C max , since in the flow shop each job visits all machines exactly once. In fact, the complexity of F m | s p r e c | C max is open, even for fixed m 3 or fixed n 3 .
  • Open problems with two jobs. The approach in Section 2 for J 2 | n = 2 , s p r e c | C max cannot be trivially extended to more than two machines. The complexity of this case is open. Additionally, an open issue is whether a more efficient algorithm can be devised for J 2 | n = 2 , s p r e c | C max , and a strongly polynomial algorithm for F m | n = 2 , s p r e c | C max .

Author Contributions

Conceptualization, A.A. F.R. and S.S.; methodology, A.A. F.R. and S.S.; validation, A.A. F.R. and S.S.; formal analysis, A.A. F.R. and S.S.; investigation, A.A. F.R. and S.S.; resources, A.A. F.R. and S.S.; writing–original draft preparation, A.A. F.R. and S.S.; writing–review and editing, A.A. F.R. and S.S.; visualization, A.A. F.R. and S.S.; supervision, A.A. F.R. and S.S.

Funding

This research received no external funding.

Conflicts of Interest

The authors declare no conflict of interest.

References

  1. Kim, E.-S.; Posner, M.E. Parallel machine scheduling with s-precedence constraints. IIE Trans. 2010, 42, 525–537. [Google Scholar] [CrossRef]
  2. Kim, E.-S.; Sung, C.-S.; Lee, I.-S. Scheduling of parallel machines to minimize total completion time subject to s-precedence constraints. Comput. Oper. Res. 2009, 36, 698–710. [Google Scholar] [CrossRef]
  3. Kim, E.-S. Scheduling of uniform parallel machines with s-precedence constraints. Math. Comput. Model. 2011, 54, 576–583. [Google Scholar] [CrossRef]
  4. Tamir, T. Scheduling with Bully Selfish Jobs. Theory Comput. Syst. 2012, 50, 124–146. [Google Scholar] [CrossRef]
  5. Demeulemeester, E.L.; Herroelen, W.S. Project Scheduling, a Research Handbook; Springer Science & Business Media: Berlin, Germany, 2006. [Google Scholar]
  6. Agnetis, A.; Lucertini, M.; Nicolò, F. Flow Management in Flexible Manufacturing Cells with Pipeline Operations. Manag. Sci. 1993, 39, 294–306. [Google Scholar] [CrossRef]
  7. Avella, P.; Boccia, M.; Mannino, C.; Vasilev, I. Time-indexed formulations for the runway scheduling problem. Transp. Sci. 2017, 51, 1031–1386. [Google Scholar] [CrossRef]
  8. Briskorn, D.; Angeloudis, P. Scheduling co-operating stacking cranes with predetermined container sequences. Discret. Appl. Math. 2016, 201, 70–85. [Google Scholar] [CrossRef]
  9. Bertel, S.; Billaut, J.-C. A genetic algorithm for an industrial multiprocessor flow shop scheduling problem with recirculation. Eur. J. Oper. Res. 2004, 159, 651–662. [Google Scholar] [CrossRef]
  10. Pinedo, M. Scheduling, Theory, Algorithms and Systems; Springer: Cham, Switzerland, 2018. [Google Scholar]
  11. Brucker, P.; Sotskov, Y.N.; Werner, F. Complexity of shop scheduling problems with fixed number of jobs: A survey. Math. Methods Oper. Res. 2007, 65, 461–481. [Google Scholar] [CrossRef]
Figure 1. In instance (a), the set A [ 2 ] B [ 2 ] does not form an INIS (initial no-idle subschedule); in instance (b) it does.
Figure 1. In instance (a), the set A [ 2 ] B [ 2 ] does not form an INIS (initial no-idle subschedule); in instance (b) it does.
Algorithms 12 00250 g001
Figure 2. Possible scenarios when M 1 completes before M 2 : (a) The INIS ( i , h ) cannot be continued, (b) it can only be continued scheduling A i + 1 , and (c) it can only be continued scheduling B h + 1 .
Figure 2. Possible scenarios when M 1 completes before M 2 : (a) The INIS ( i , h ) cannot be continued, (b) it can only be continued scheduling A i + 1 , and (c) it can only be continued scheduling B h + 1 .
Algorithms 12 00250 g002
Figure 3. (a) The graph G ( 0 , 0 ) in the example. (b) The INIS [ ( 0 , 0 ) ( 2 , 2 ) ] .
Figure 3. (a) The graph G ( 0 , 0 ) in the example. (b) The INIS [ ( 0 , 0 ) ( 2 , 2 ) ] .
Algorithms 12 00250 g003
Figure 4. (a) The best schedule starting with the INIS [ ( 0 , 0 ) ( 2 , 2 ) ] , and (b) the optimal schedule in the example.
Figure 4. (a) The best schedule starting with the INIS [ ( 0 , 0 ) ( 2 , 2 ) ] , and (b) the optimal schedule in the example.
Algorithms 12 00250 g004
Figure 5. Graph G ( 1 , 1 ) in the example.
Figure 5. Graph G ( 1 , 1 ) in the example.
Algorithms 12 00250 g005
Figure 6. Three schedules for Example 2.
Figure 6. Three schedules for Example 2.
Algorithms 12 00250 g006
Figure 7. A sample schedule for F m | n = 2 , s p r e c | C max . The tasks of job A are in grey.
Figure 7. A sample schedule for F m | n = 2 , s p r e c | C max . The tasks of job A are in grey.
Algorithms 12 00250 g007
Back to TopTop