Abstract 1 Introduction 2 Preliminaries 3 Parameterization by the number of predecessors 4 Parameterization by the number of successors 5 Parameterization by the number of machines 6 Summary and Outlook References

Parameterized Complexity of Scheduling Unit-Time Jobs with Generalized Precedence Constraints

Christina Büsing ORCID Research and Teaching Area for Combinatorial Optimization, RWTH Aachen University, Germany Maurice Draeger ORCID RWTH Aachen University, Germany Corinna Mathwieser111corresponding author ORCID Research and Teaching Area for Combinatorial Optimization, RWTH Aachen University, Germany
Abstract

We study the parameterized complexity of scheduling unit-time jobs on parallel, identical machines under generalized precedence constraints for minimization of the makespan and the sum of completion times (P|gen-prec,pj=1|γ, γ{Cmax,jCj}). In our setting, each job is equipped with a Boolean formula (precedence constraint) over the set of jobs. A schedule satisfies a job’s precedence constraint if setting earlier jobs to true satisfies the formula. Our definition generalizes several common types of precedence constraints: classical and-constraints if every formula is a conjunction, or-constraints if every formula is a disjunction, and and/or-constraints if every formula is in conjunctive normal form. We prove fixed-parameter tractability when parameterizing by the number of predecessors. For parameterization by the number of successors, however, the complexity depends on the structure of the precedence constraints. If every constraint is a conjunction or a disjunction, we prove the problem to be fixed-parameter tractable. For constraints in disjunctive normal form, we prove W[1]-hardness. We show that the and/or-constrained problem is 𝒩𝒫-hard, even for a single successor. Moreover, we prove 𝒩𝒫-hardness on two machines if every constraint is a conjunction or a disjunction. This result not only proves para-𝒩𝒫-hardness for parameterization by the number of machines but also complements the polynomial-time solvability on two machines if every constraint is a conjunction ([4]) or if every constraint is a disjunction ([11]).

Keywords and phrases:
scheduling, precedence constraints, fixed-parameter tractability, complexity
Copyright and License:
[Uncaptioned image] © Christina Büsing, Maurice Draeger, and Corinna Mathwieser; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Mathematics of computing Combinatorial optimization
Editors:
Akanksha Agrawal and Erik Jan van Leeuwen

1 Introduction

Scheduling jobs with precedence constraints on identical parallel machines is a well-researched problem with many real-world applications. A classical precedence constraint between two jobs, say from job i to job j, means that job j cannot begin until job i has finished. If job j has multiple such constraints, it can only start once all the predecessor jobs have been completed. However, many real-life settings find classical precedence constraints (and-type constraints) too restrictive. It may not always be necessary to complete all predecessors before starting a job. This need for flexibility has led to the proposal of alternative variants of precedence constraints in the literature. The first variant is or-precedence constraints where completing any predecessor is sufficient to start a job. The second variant includes and+or-constraints where some jobs require all predecessors to be completed earlier (and-jobs) while others only require to be preceded by only one predecessor (or-jobs). Another more general variant is known as and/or-constraints. In this model, each job has multiple groups of predecessor jobs, and to start the job, at least one job from each group must be completed first. A motivating example for and/or-constraints is provided by Goldwasser, Lotombe and Motwani ([7]), who examine the problem of disassembling a product. Certain parts may need to be taken out prior to accessing other components. Occasionally, the same part might be accessible from various directions and therefore, removing any of several different components may provide access to a particular part. Scheduling with a combination of or- and and-constraints has further been studied in the works of Gillies and Liu [6], Möhring et al. [17], Lee et al. [13] and Erlebach et al. [5]. For scheduling under solely or-constraints, we refer to the works of Berit [11] and the paper by Happach [10].

Given the diverse landscape of precedence constraint types, we propose a more general notion of precedence constraints, which encompasses all aforementioned types. Specifically, we encode precedence constraints regarding a specific job j as a logical formula ψj over (unnegated) variables representing the set J of jobs: {xiiJ}. In any feasible schedule, ψj must be satisfied by the assignment resulting from setting xi=1 precisely if job i is executed prior to j. Our definition gives rise to and-constraints when each ψj is a conjunction; to or-constraints when each ψj is a disjunction; to and+or-constraints when each ψj is either; and to and/or-constraints when each ψj takes conjunctive normal form. Naturally, another interesting variant arises when each ψj is expressed in disjunctive normal form. We refer to this new variant as or/and-constraints. To gain an intuitive motivation of or/and-constraints, consider the following example from disaster management: There are several routes that can be used to evacuate people from a village, but obstacles (such as debris or fallen trees) are blocking these routes. To proceed with the evacuation, it might not be essential to clear all routes yet but it is necessary to remove all obstacles from one route.

The study of parameterized algorithms as an approach to addressing computationally hard problems is a vibrant field of research that has gained significant momentum in the scheduling community in recent years ([15], [19], [3], [1], [18], [16], [12]). In the context of classical precedence-constrained scheduling problems, the most common parameters include the number of machines, the width of the partial order that is induced by the precedence constraints, and the maximum processing time. Observe that the effect of precedence constraints on the complexity of scheduling problems can be twofold: On the one hand, the additional structure imposed by precedence constraints can simplify scheduling problems. An extreme example is when precedence constraints result in a total order among all jobs, rendering scheduling problems trivial. On the other hand, precedence constraints can also turn polynomial-time solvable scheduling problems into 𝒩𝒫-hard problems (Prot and Bellenguez-Morineau [19]): Scheduling unit-time jobs on parallel identical machines while minimizing the makespan or the (weighted) sum of completion times becomes 𝒩𝒫-hard in the presence of and-precedence constraints (Lenstra and Kan [14], Sethi [20]). Restricting the width of the partial order in classical precedence-constrained scheduling seeks to exploit the former effect: A small width generates high interrelatedness between the jobs and may thus provide scheduling problems with more structure. Yet, this approach does not necessarily result in fixed-parameter tractability, not even in combination with other classical parameters. Bodlaender and Fellows ([2]) show that even P|prec,pj=1|Cmax is W[2]-hard when parameterized by the width and the number of machines and Van Bevern et al. show in [21] that P2|prec,pj{1,2}|Cmax is W[2]-hard when parameterized by the width. The diversity in the forms that precedence constraints can take – and the observation that enforcing dense dependency structures does not necessarily improve tractability – motivates the introduction of new parameters for generalized precedence constraints which limit interrelatedness.

Our Contribution

We study the problem P|gen-prec,pj=1|γ of scheduling unit-time jobs on parallel, identical machines under generalized precedence constraints and consider the objectives of minimizing the makespan (γ=Cmax) or the sum of completion times (γ=jCj). We investigate the parameterized complexity with respect to three parameters: the number kp of predecessors, the number ks of successors and the number m of machines. We achieve fixed-parameter tractability when parameterizing by the total number kp of jobs that appear as predecessors in any precedence constraint, by providing a single-exponential algorithm. For the number ks of successors however, the picture is more diverse and depends on the structure of the precedence constraints. For and+or-constraints, we prove the problem to be fixed-parameter tractable (FPT) by providing an algorithm with doubly-exponential dependence on ks. This result does not extend to and/or- nor to or/and-constraints: We prove that P|and/or-prec,pj=1|γ is para-𝒩𝒫-hard with respect to ks by showing that the problem is 𝒩𝒫-hard, even for a single successor. For or/and-constraints, we prove the problem to be in XP and to be W[1]-hard. Since Berit provides in [11] a polynomial-time algorithm for scheduling unit-time jobs on parallel, identical machines under or-constraints, it makes sense to ask if and+or-constrained scheduling remains FPT when only restricting the number ksandks of and-successors. However, we prove that scheduling under and+or-constraints is 𝒩𝒫-hard, even if there is only one and-job. Since our reduction only makes use of two machines, we also obtain that P|and+or,pj=1|γ is para-𝒩𝒫-hard with respect to the number m of machines.

2 Preliminaries

Problem Definition

We consider the problem of non-preemptively scheduling unit time jobs on identical, parallel machines under generalized precedence constraints. An instance specifies a set J={1,,n} of jobs, a number m of identical machines and occasionally job weights wj0, jJ. A schedule 𝒮 specifies which job, if any, each machine works on at each point in time. More precisely, a schedule 𝒮 is represented as tuple (Cj)jJ, where Cj indicates the completion time of each job jJ. Since m jobs can be processed in parallel, we assume that |{jJCj=t}|m for any time t. We say that a job i precedes a job j in 𝒮 if Ci<Cj. Moreover, we refer to the period between time t1 and time t as time slot t.

Precedence constraints comprehend the requirement that certain jobs have to be finished before others can be started. In order to formalize precedence constraints, we introduce a Boolean variable xj{0,1} for each job jJ. Moreover, we denote by 𝟙 the logical one that represents the truth value “true”. We encode precedence constraints as family (ψj)jJ, where each ψj, jJ, is a Boolean formula over the (unnegated) variables in {xiiJ}{𝟙}. If a variable xi occurs in a precedence constraint ψj, i,jJ, then i is called a predecessor of j and j is called a successor of i. A job iJ, which is the predecessor of some other job, is called a predecessor. Likewise, a job jJ with non-trivial precedence constraint ψj𝟙, is called a successor. We refer by kp (ks) to the number of predecessors (successors).

A schedule 𝒮 is associated with variable assignments xj(𝒮), jJ, which set xij(𝒮)=1 precisely if i precedes j in 𝒮. A schedule 𝒮 is called feasible with respect to precedence constraints (ψj)jJ if each ψj, jJ, is satisfied by setting xi=xij(𝒮) for iJ. Given a schedule 𝒮, we call a job j available at time t if the variable assignment that sets xi=1 precisely if Cit is a true assignment for ψj. We consider three classical objectives: Minimizing the makespan (γ:=Cmax=maxjJCj), minimizing the sum of completion times (γ:=jCj) or minimizing the weighted sum of completion times, (γ:=jwjCj). Following standard notation as introduced by Graham et al. in [9], we refer to the problem of finding an optimal schedule by P|gen-prec,pj=1|γ. Here, P means identical parallel machines, pj=1 indicates unit processing times for all jobs, and γ{Cmax,jCj,jwjCj} specifies the objective function. If we consider the problem for two instead of arbitrarily many machines, we write P2|gen-prec,pj=1|γ. Given an instance I of P|gen-prec,pj=1|γ, we denote the objective value of an optimal solution by OPT(I) and of a specific schedule 𝒮 by γ(𝒮). We distinguish five special cases of P|gen-prec,pj=1|γ, γ{Cmax,jCj,jwjCj}:

  • P|prec,pj=1|γ, where each ψj is a conjunction,

  • P|or-prec,pj=1|γ, where each ψj is a disjunction,

  • P|and+or-prec,pj=1|γ, where each ψj is either a conjunction or a disjunction,

  • P|and/or-prec,pj=1|γ, where each ψj is in conjunctive normal form,

  • P|or/and-prec,pj=1|γ, where each ψj is in disjunctive normal form.

Feasibility and objectives

A feasible schedule for P|gen-prec,pj=1|γ can be calculated in polynomial time by repeatedly choosing an available job and assigning it to any free machine. For a precise description, we refer to Algorithm 1 by Möhring et al. [17], which was formulated for and/or-constraints but can be easily implemented for generalized precedence constraints. In case of classical and-constraints, infeasibility is equivalent to the existence of a cycle in the precedence graph G, where G is a digraph with node set J and arc set

A={(i,j)i,jJ, i is a predecessor of j}.

Throughout this paper, we assume that all instances are feasible.

Scheduling with unit-time jobs has the advantage that we can minimize the makespan and the sum of completion times simultaneously. While not every feasible schedule with minimum makespan necessarily optimizes the sum of completion times, the reverse holds true (which can be seen through standard swapping arguments). Subsequently, it suffices to only prove the correctness of algorithms for γ=j(wj)Cj and hardness for γ=Cmax.

List Scheduling

List scheduling is a simple and intuitive method for addressing scheduling problems and was introduced by Graham in [8]. The approach involves assigning a priority to each job, creating an ordered list based on these priorities. Jobs are then scheduled in the order they appear on this list. Whenever a machine is free, it is assigned the first unscheduled job from the list that is available to be processed at that time. List scheduling ensures machines are never left idle intentionally – idle time only occurs when no jobs are currently available for processing. This method can be efficiently implemented and runs in polynomial time.

3 Parameterization by the number of predecessors

In this section, we analyze the parameterized complexity regarding the overall number kp of predecessors. Note that the parameters kp and ks are, in a sense, conceptually opposed to width. While a small width typically indicates that most jobs are highly interrelated, having few predecessors or successors often leads to many jobs being largely independent. A small width is therefore used to enforce structure in scheduling problems that are hard without precedence constraints. In contrast, parameterizing by kp or ks aims to capture the effect of introducing a limited number of precedence constraints into problems that are efficiently solvable when no precedence constraints are present (as is the case for unit processing times). In the following, we prove that P|gen-prec,pj=1|γ, γ{Cmax,jCj} is FPT when parameterized by the number of predecessors (see Theorem 2). For minimizing the weighted sum of completion times, we prove the weaker result that P|gen-prec,pj=1|jwjCj lies in 𝒫 if kp is bounded by a constant. In either case, we provide an algorithm that essentially explores all possibilities of positioning the predecessors in a schedule and later inserts all other jobs via List Scheduling. To test fewer possibilities, we argue that we may assume all predecessors to be processed before time step kp if γ{Cmax,jCj}.

Lemma 1.

Let I=(J,(ψj)jJ,m) be a feasible instance of P|gen-prec,pj=1|γ, γ{Cmax,jCj} with a set JpJ of kp predecessors. Then there exists an optimal schedule 𝒮 with completion times (Cj)jJ such that Cjkp for all jJp.

Proof.

Let 𝒮=(Cj)jJ be a schedule with optimal sum of completion times. Assume Cj>kp for some jJp. Let tkp be the earliest time slot where no predecessor is processed. Choose a job iJ with Ci=t. By choice of t, i is not a predecessor job. Let h be an earliest predecessor with Ch>t. Construct a schedule 𝒮 from 𝒮 by swapping i and h. Clearly, the swap is feasible and does not alter the sum of completion times. Thus 𝒮 is optimal too, while the earliest time slot t where no predecessor is processed has increased, t>t. Repeat until all completion times of predecessor jobs do not exceed kp.

The algorithm alg-pre for instances of P|gen-prec,pj=1|γ, γ{Cmax,jCj,jwjCj}, with predecessors Jp={i1,,ikp}J proceeds as follows: Repeatedly pick a configuration (Ci)=1kp of predecessor completion times from 𝒞:={1,,kp}kp if γ{Cmax,jCj} or from 𝒞:={1,,n}kp if γ=jwjCj. If (Ci)=1kp is a feasible schedule for Jp, insert all remaining jobs through List Scheduling in order of non-increasing weight and return the schedule with the smallest objective value.

Theorem 2.

Let I be a feasible instance of P|gen-prec,pj=1|γ, γ{Cmax,jCj,jwjCj} with kp predecessors. If γ{Cmax,jCj}, then alg-pre returns in 𝒪(kpkpmn2) time the completion times of an optimal schedule 𝒮. Otherwise, alg-pre returns in 𝒪(nkp+2m) time the completion times of an optimal schedule 𝒮.

Proof.

Let 𝒮=(Cj)jJ be an optimal schedule, such that (Ci1,,Cikp)𝒞. (The existence of such 𝒮 follows from Lemma 1). Consider the iteration of alg-pre where Cj=Cj for all jJp. Clearly, the algorithm computes a feasible schedule 𝒮=(Cj)jJ. Denote by kpt the number of predecessor jobs processed during time slot t{1,,n}.

We prove the optimality of 𝒮=(Cj)jJ for γ=jwjCj, from which the statement for the other two objectives follows immediately. Assume the jobs in JJp have 1qnkp different weights that we denote by w1w2wq. We consider the vector z(t)=(z1(t),,zq(t))q where zi(t), i{1,,q}, denotes the number of jobs in JJp with weight wi that 𝒮 processes during time slot t. For 𝒮, we define z(t), t, analogously. If z(t)=z(t) for all t, then jwjCj=jwjCj and 𝒮 is optimal. Otherwise, let T:=min{tz(t)z(t)} be the smallest time slot for which z(T),z(T) are not equal.

Assume first that z(T) is lexicographically smaller than z(T). Let i{1,,q} be such that zs(T)=zs(T) for s<i and zi(T)>zi(T). It holds that t=1Tzi(t)<t=1Tzi(t). Subsequently, there exists a job jJ with weight wj=wi, such that CjT but Cj>T. Observe that j is not a predecessor, otherwise Cj=Cj. Since CjT, job j is available at time T1 in 𝒮 and thus also in 𝒮. Since alg-pre sets Cj>T, the following holds: When j is considered, the algorithm has already occupied all machines during time slot T, namely with predecessor jobs or jobs with weight at least wj=wi. This yields a contradiction as

m=kpT+szs(T) =kpT+s<izs(T)+zi(T)=kpT+s<izs(T)+zi(T)
<kpT+s<izs(T)+zi(T)m.

Assume now that z(T) is lexicographically smaller than z(T) and let again i{1,,q} be such that zs(T)=zs(T) für s<i while zi(T)<zi(T). By analogous arguments, there exists a job jJJp with weight wi such that CjT, Cj>T and j is available at time T1 in 𝒮.

The optimal schedule 𝒮 occupies all machines during time slot T with predecessor jobs or jobs of weight at least wj=wi: Otherwise, swapping j with a job of smaller weight or placing it on an idle machine during time slot T would yield a feasible solution with smaller weighted sum of completion times. As before,

m=kpT+s<izs(T)+zi(T)<kpT+s<izs(T)+zi(T)m

yields a contradiction.

We conclude with a brief runtime analysis: We sort all non-predecessor jobs with respect to weight once (𝒪(nlogn) time). Then the algorithm checks |𝒞| configurations (t1,,tkp)𝒞 of predecessor completion times. For each such configuration, the algorithm inserts 𝒪(n) jobs jJJp. For each job jJJp, it checks for 𝒪(n) time steps t whether j is available at time t. For any such time step t, the algorithm searches for an idle machine among m machines. Since, |𝒞|𝒪(kk) if γ{Cmax,jCj} and |𝒞|𝒪(nk) otherwise, the claimed asymptotic runtime follows.

4 Parameterization by the number of successors

We investigate whether restricting the number of successors has the same effect as restricting the number of predecessors. However, it turns out that the parameterized complexity with respect to the number of successors depends on the structure of the precedence constraints. More precisely, we prove that P|and+or-prec,pj=1|γ, γ{Cmax,jCj} is FPT when parameterized with respect to the number ks of successors. For the more general or/and-constraints, we prove that P|or/and-prec,pj=1|γ, γ{Cmax,jCj} is polynomial-time solvable if the number ks of successors is bounded by a constant. We show that this result cannot be improved to fixed-parameter tractability by proving that P|or/and-prec,pj=1|γ, γ{Cmax,jCj} is W[1]-hard when parameterized by the number ks of successors. For and/or-constraints, we prove para-𝒩𝒫-hardness. Throughout this section, we assume γ{Cmax,jCj}.

To prove that P|and+or-prec,pj=1|γ is FPT with respect to ks, we proceed as follows: 1. We provide an FPT algorithm and-alg-succ for instances of P|prec,pj=1|γ with ks successors. 2. We argue how to solve P|and+or-prec,pj=1|γ by repeatedly calling and-alg-succ. Algorithm and-alg-succ is similar to alg-pre and explores all possibilities of positioning the successors in a schedule before inserting all other jobs. To avoid naïvely testing all 𝒪(nkp) possible ways to schedule the successors, we use a similar result to Lemma 1: We may assume all successors to be processed within a time span of length ks.

Lemma 3.

Let I=(J,(ψj)jJ,m) be a feasible instance of P|gen-prec,pj=1|γ, γ{Cmax,jCj} with ks successors and let JsJ denote the set of successors. Then there exists an optimal schedule 𝒮=(Cj)jJ, such that CjCiks1 for all i,jJs.

Proof.

Consider an optimal schedule 𝒮 with completion times C¯, J, and assume that C¯maxsC¯mins>ks1 where C¯mins=min{C¯Js} is the completion time of an earliest successor and C¯maxs=max{C¯Js} is the completion time of a latest successor. Let t be the earliest time slot with C¯mins<t<C¯maxs where no successor is processed. Pick a job jJJs with Cj=t. Let i be a successor with Ci=t1. We construct from 𝒮 another feasible schedule 𝒮 with completion times C, J, by swapping jobs i and j. Clearly, 𝒮 is feasible and optimal and Cmaxs:=max{CJs}=C¯maxs. If t1=C¯mins and i is the only successor with C¯i=t1, then Cmins:=min{CJs}>C¯mins. Else, if t1>C¯mins and i is again the only successor with C¯i=t1, then Cmins=C¯mins but the earliest time slot t(Cmins,Cmaxs) without successors in 𝒮 has decreased, t<t. Otherwise, we also get Cmins=C¯mins while the overall number of time slots t(Cmins,Cmaxs) without successors in 𝒮 has decreased. By repeating the argument, we obtain an optimal solution where all successors are processed within a time span of length ks.

Given a set JsJ of successors, the algorithm and-alg-succ repeatedly picks a configuration (Cj)jJs from

𝒞:={(tj)jJs{1,,n}ksi,jJs:titjks1},

such that |{jJsCj=t}|m for all t{1,,n} and ti<tj if i is a predecessor of j. Then the algorithm inserts the remaining jobs as follows: and-alg-succ iterates over all successors in order of non-decreasing completion times. For each successor jJs, the algorithm assigns the earliest possible completion time to each predecessor. If some predecessor cannot be scheduled before j, the respective schedule of successors is discarded. In the end, all remaining jobs (which are neither successor nor predecessor) are inserted as early as possible.

Proposition 4.

Let I be a feasible instance of P|prec,pj=1|γ, γ{Cmax,jCj} with ks successors. Then and-alg-succ returns in 𝒪(ksksmn3) time an optimal schedule 𝒮.

Proof.

By Lemma 3, there exists an optimal schedule 𝒮 with completion times Cj, jJ such that (Ci1,,Ciks)𝒞. Consider the iteration of and-alg-succ where Cj=Cj for all jJs. Since 𝒮 is a feasible schedule with identical successor completion times, there is enough space on the machines prior to each successor jJs for and-alg-succ to schedule all of j’s predecessors. Hence, (Ci1,,Ciks) is not discarded and and-alg-succ computes a feasible schedule 𝒮. We proceed by proving that 𝒮 is in fact optimal. We define z(t) as the number of jobs in {jJJsCj=t}, which 𝒮 processes during time slot t. For 𝒮, we define z(t), t, analogously. If z(t)=z(t) for all t, then (Cmax,jCj)=(Cmax,jCj) and 𝒮 is optimal. Otherwise, let T:=min{tz(t)z(t)} be the smallest time slot for which z(T),z(T) are not equal.

Assume first that z(T)<z(T). It holds that t=1Tz(t)<t=1Tz(t). Subsequently, there exists a job jJ, such that CjT but Cj>T. Observe that j is no successor, otherwise Cj=Cj. When and-alg-succ assigns a completion time to j, there is an idle machine during time slot T because z(T)<z(T)m and and-alg-succ assigns a completion time CjT to j, contradiction. If z(T)>z(T), there exists a job jJJs, such that Cj>T but CjT. The optimal schedule 𝒮 has an idle machine during time slot T because z(T)<z(T)m. Adapting the optimal solution such that Cj=T does not negatively affect neither the optimality of 𝒮 nor its feasibility since j has no predecessors. We repeat this argument until z(t)=z(t) for all t, which proves that 𝒮 is optimal. We omit a runtime analysis since it is analogous to the proof of Theorem 2.

Using and-alg-succ, it is easy to see that P|or/and-prec,pj=1|γ, γ{Cmax,jCj}, lies in 𝒫 if the number of successors ksconst is bounded by some constant const0: Recall that or/and-constraints require each precedence constraint ψj, jJ, to be a disjunction of conjunctive clauses. By electing one clause per job, we can solve an instance I of P|or/and-prec,pj=1|γ by solving 𝒪(|I|ks) instances of P|prec,pj=1|γ with at most ks successors. We state this in the following corollary:

Corollary 5.

P|or/and-prec,pj=1|γ can be solved in polynomial-time if the number of successors ksconst is bounded by a constant const0.

For and+or-constraints, we can strengthen this argument to prove that P|and+or-prec,pj=1|γ, γ{Cmax,jCj} is FPT. Consider an instance I=(J,(ψj)jJ,m) of P|and+or-prec,pj=1|γ with ks successors. Let Js=Jsand˙Jsor be a partition of the set of successors, where a precedence constraint ψj of a job jJs is a conjunction if jJsand and a disjunction if jJsor. We call jobs in Jsand and-jobs and jobs in Jsor or-jobs. Consider an or-job jJsor and let iJ be a predecessor of j. Consider the alternate instance I=(J,(ψj)jJ,m) that we obtain by fixing i as only predecessor of j, that is, ψ=ψ if j and ψj=xi. Clearly, any optimal schedule 𝒮 for I is feasible for I too. However, whether 𝒮 is optimal for I too, strongly depends on whether i is also a predecessor of other jobs in Js{j}. See Figure 1 for an example. Consider an arbitrary feasible schedule 𝒮 for I. For each or-job jJsor, we can determine a predecessor job ij of j such that ij precedes j in 𝒮. Observe that we can possibly have ij=ik for two different or-jobs j,kJsor, jk, and that each ij may be a predecessor of multiple and-successors. In other words, the choice of (ij)jJsor gives rise to a function σ:Jsor2Js where kσ(j) precisely if k is an or-job and ij=ik or if k is an and-job with predecessor ij. Our algorithm essentially tests all relevant variations of σ and picks an and-predecessor ijJ for each or-job jJs according to σ, before it applies and-alg-succ to the resulting instance with and-constraints.

Figure 1: We process six jobs a,b,c,d,e,f with and+or-precedence constraints ψe=xaxbxc, ψf=xaxd on three machines. The left schedule is optimal for the and-variation with ψf=xd. The schedule on the right is optimal for the and-variation with ψf=xa and for the original instance.
Definition 6.

Let I=(J,(ψj)jJ,m) be an instance of P|and+or-prec,pj=1|γ, γ{Cmax,jCj} where Js=Jsor˙Jsand is the set of successors. For each or-job jJsor, let ijJ be a predecessor of j.

  1. 1.

    Let σ:Jsor2Js be a function such that kσ(j), jJsor, precisely if kJsor and ij=ik or if kJsand with predecessor ij. We call σ the common predecessor function of I with respect to (ij)jJsor.

  2. 2.

    If σ:Jsor2Js is a common predecessor function of I with respect to (ij)jJsor, we call (ij)jJsor generating representatives of σ.

  3. 3.

    Let I=(J,(ψj)jJ) be the P|prec,pj=1|γ instance with ψj=ψj if jJsor and ψj=xij if jJsor. We call I the and-variation of I with respect to (ij)jJsor.

Observe the following properties of a common predecessor function σ:Jsor2Js: First, jσ(j) for all jJsor. If j,kJsor and kσ(j), then σ(j)=σ(k). If σ is the common predecessor function of I with respect to (ij)jJsor, then ij is a predecessor of every kσ(j), jJsor. Lastly, note that σ may have different generating representatives (ij)jJsor, (ij)jJsor, (ij)jJsor(ij)jJsor. The following lemma proves that for a given common predecessor function, the choice of generating representatives is irrelevant (under certain conditions).

Lemma 7.

Let I=(J,(ψj)jJ,m) be a P|and+or-prec,pj=1|γ instance, γ{Cmax,jCj}, with successor set Js=Jsor˙Jsand. Let σ,σ:Jsor2Js be common predecessor functions of I with respect to (ij)jJsor,(ij)jJsor respectively. Let L,L be the and-variations of I with respect to (ij)jJsor,(ij)jJsor respectively. If

Is:={jJsorijJs}={jJsorijJs} and ij=ij for all jIs,

then L is feasible precisely if L is feasible. In this case, OPT(L)=OPT(L) if moreover σ=σ and ij=ik whenever ij=ik, j,kJsor.

Proof.

Assume that L is infeasible and let C=(j1,,jr) be a cycle in the precedence graph, j0:=jr. Consider a job j in the cycle, {1,,r}. If jJsand is an and-job in I, then j1 is also a predecessor of j in L. If jJsor, then j1=ij. Since j1 is a successor in L, it is also a successor in I and thus j1=ij=ij is also a predecessor of j in L. Therefore, the precedence graph of L contains the same cycle C and L is infeasible.

Assume now that L is feasible, σ=σ and ij=ik whenever ij=ik, j,kJsor. Let (Cj)jJ be the completion times of an optimal schedule 𝒮. We define a schedule 𝒮 with completion times (Cj)jJ for L. We denote the sets in {σ(j)JsorjJsor} by S1,,Sr. Observe that (S)=1r is a partition of Jsor and that S=σ(j)Jsor precisely if S=σ(j)Jsor, jJsor,=1,,r. For each =1,,r, let i(),i()Jsor be the common predecessor with i()=ik,i()=ik for all kS. We obtain 𝒮 from 𝒮 by swapping the positions of i() and i() for all =1,,r. Observe that this is in fact the same as setting Cik=Cik and Cik=Cik for kJsor. All other jobs jJ remain as in 𝒮, i.e. Cj=Cj. Note that the schedule 𝒮 is well-defined, since we require i()=i(p) if i()=i(p) for ,p=1,,r. Clearly, γ(𝒮)=γ(𝒮). It remains to show that 𝒮 is feasible. To this end, let kJs be a successor job in I. Observe that Ck=Ck: If ki,i for all Jsor, then Ck=Ck by definition of Ck. Otherwise, if k=i or k=i for some Jsor, then Is and thus k=i=i and Ck=Ck. Assume now that kJsand is an and-job in I and let jJ be a predecessor of k in L. Clearly, j is also a predecessor of k in L and thus Cj<Ck. If Cj=Cj, then j precedes k in 𝒮 because Cj=Cj<Ck=Ck. Otherwise, j=i or j=i for some Jsor with ii. Assume first that j=i. Since k is an and-job in I with predecessor i=j, it follows that kσ()=σ(). By definition of σ, job i is a predecessor of k in I and L and thus Cj=Ci<Ck=Ck. We can show analogously that Cj<Ck if j=i. Finally, let kJsor be a former or-job. By definition of L, the job ik is the only predecessor of k in L and ik is the only predecessor of k in L. Subsequently, Cik=Cik<Ck=Ck, which completes the proof.

We now describe the algorithm and+or-alg-succ for P|and+or-prec,pj=1|γ, γ{Cmax,jCj}, in more detail. First, and+or-alg-succ picks completion times Cj, jJs, for the successors in the same way as and-alg-succ. For every or-job jJsor with a predecessor iJs with Ci<Cj, we set ij=i. Afterwards, and+or-alg-succ iterates over all or-jobs j1,,jqJsor in order of non-decreasing completion time Cj1Cjq. If no iji has been chosen yet, we pick a subset Sj{ji,,jq}Jsand of successor jobs with jSj. Then we pick a job iJ such that the successors of i in {ji,,jq}Jsand are precisely the vertices in Sj. We set ik=i for all kSjJsor. (If such a job i does not exist, Sj is an infeasible choice.) Finally, the algorithm and+or-alg-succ proceeds along the same lines as and-alg-succ for the and-variation of I w.r.t. (ij)jJsor.

Theorem 8.

Let I be a feasible instance of P|and+or-prec,pj=1|γ, γ{Cmax,jCj} with ks successors. Then and+or-alg-succ returns in 𝒪(ksks2ks2mn3) time the completion times of an optimal schedule 𝒮.

Proof.

Let Js=Jsor˙Jsand be the set of successors with |Js|=ks and q:=|Jsor|. By Lemma 3, there exists an optimal schedule 𝒮=(Cj)jJ such that (Ci1,,Cikp)𝒞. Consider the iteration of and+or-alg-succ where Cj=Cj for all jJs and let 𝒮 denote the schedule defined by (Cj)j. Let j1,,jq be the ordering, in which and+or-alg-succ iterates over the or-jobs. We denote by Is the set of or-jobs jJsor, to which and+or-alg-succ assigns a predecessor ijJs.

The idea of the proof is the following: First, we pick (ij)jJsor such that ij is a predecessor of j with Cij<Cj, jJsor. We argue, that for a certain choice of (Sj)j, the algorithm computes representatives (ij)jJsor such that (ij)j,(ij)j as well as the associated common predecessor functions σ,σ comply with the conditions in Lemma 7.

More precisely, we pick (ij)jJsor as follows: Consider the or-jobs j in order j=j1,,jq. We set ij=ij for jIs. If j=ji and no ij has been chosen yet, we pick an arbitrary predecessor ij with Cij<Cj but set ik=ij for all k=ji+1,,jq, of which ij is also a predecessor. We denote by σ:Jsor2Js the common predecessor function of I w.r.t. (ij)jJsor and consider the iteration where and+or-alg-succ sets Sji=σ(ji){j1,,ji1} for i=1,,q. Observe that whenever and+or-alg-succ is required to pick ij according to Sj, then Sj=σ(j), otherwise ij would have been chosen in an earlier iteration. Due to the choice of (Sj)j and the properties of (ij)j, and+or-alg-succ can find an ij for j=jr such that 1. ij is a predecessor of all jobs in Sj and 2. ij is not a predecessor of any job in (Jsand{jr+1,,jq})Sj. We denote by σ:Jsor2Js the common predecessor function of I w.r.t. (ij)jJsor. Then it is easy to verify that (ij)j,(ij)j,σ,σ comply with the conditions in Lemma 7, which completes the proof. We have shown that P|or/and-prec,pj=1|γ is polynomial-time solvable if the number ks of successors is bounded by a constant while P|and+or-prec,pj=1|γ is even FPT with respect to the number of successors. Recall that Berit [11] proved the or-constrained problem P|or,pj=1|γ to be polynomial-time solvable, even if no restrictions are made on the number of successors. Naturally, three questions arise:

  1. 1.

    Is P|or/and-prec,pj=1|γ FPT when parameterized by ks? We give a negative answer to this question by proving that P|or/and-prec,pj=1|γ is W[1]-hard (see Theorem 9).

  2. 2.

    Is P|and/or-prec,pj=1|γ polynomial-time solvable if the number ks of successors is bounded by a constant? We will give a negative answer to this question by proving that P|and/or-prec,pj=1|γ is 𝒩𝒫-hard, even if ks=1 (see Proposition 11).

  3. 3.

    Is P|and+or-prec,pj=1|γ FPT with respect to the number of and-successors? Surprisingly, P2|and+or-prec,pj=1|γ turns out to be para-𝒩𝒫-hard when parameterized by the number of and-successors. In fact, we prove that the problem is 𝒩𝒫-hard, even if there is only a single and-successor (see Theorem 13).

Theorem 9.

P|or/and-prec,pj=1|γ, γ{Cmax,jCj} is W[1]-hard when parameterized by the number ks of successors.

Figure 2: Reduction from Independent Set with k=2 to P|or/and-prec,pj=1|γ with ks=2k+1. Blue jobs and preceding orange jobs represent the size and selection of an independent set. In schedules with Cmax=2k+1, green (red) jobs are used to block space after (before) blue jobs.

Proof.

We prove the claim by an FPT-reduction from Independent Set. Let I=(G,k) be an instance of Independent Set where G=(V,E) is an undirected graph with n:=|V| nodes and k0 is the required size of an independent set, w.l.o.g. k<n. By

𝒩¯(v):={wV{v,w}E}{v}

we denote the closed neighborhood of a vertex vV. We construct from I an instance I of P|or/and-prec,pj=1|Cmax with n machines and require a makespan of at most 2(k+1). An interpretation of the construction is given below. We introduce 2(k+kn)+1 jobs by setting

J:={uii=1,,k}{Niv,bivi=1,,k,vV}{hii=1,,k+1}.

The precedence constraints are defined as follows: Jobs Niv,biv in the second subset do not have predecessors. The auxiliary jobs h1,,hk+1 have to be scheduled in a chain that follows the completion of all ui, i=1,,k. That is, ψhi+1=xhi for all i=1,,k and ψh1=i=1kxui. The precedence constraint of a job ui is the disjunction ψui=vVKiv of n clauses Kiv, where

Kiv:=u𝒩¯(v)xNiuu𝒩¯(v)xbiuj<ixNjv, i=1,,k,vV.

We interpret vV as the i-th node in the independent set if Kiv is satisfied by the jobs that precede ui, i=1,,k. In a schedule with makespan 2(k+1), the chain of the auxiliary jobs h1,,hk+1 guarantees that all jobs u1,,uk have to be completed by time k+1. This leaves a total of at most kn time slots to schedule the predecessors that are needed to make u1,,uk available. However, each clause Kiv is composed of n+i1 literals in a way that each of the last i1 predecessors Njv, j=1,,i1, has to be a common predecessor with uj, due to the space restrictions. Due to this, a node vi for which Kivi is satisfied is disjoint and non-adjacent to the nodes vj for which the previous i1 clauses Kjvj are satisfied, j=1,,i1. Figure 2 depicts an example of the construction. Since an optimal schedule for γ=jCj simultaneously optimizes the makespan, the hardness for the sum of completion times follows too. From the proof of Theorem 9, we moreover get the following corollary:

Corollary 10.

P|or/and-prec,pj=1|Cmax is W[1]-hard if parameterized by Cmax and ks.

Given the complexity result in Theorem 9, the existence of a fixed-parameter tractable algorithm for P|or/and-prec,pj=1|γ parameterized by ks is unlikely. In the context of and/or-constraints, we provide even stronger evidence against the fixed-parameter tractability of P|and/or-prec,pj=1|γ parameterized by ks, by proving that the problem is para-𝒩𝒫-hard.

Proposition 11.

P|and/or-prec,pj=1|γ, γ{Cmax,jCj} is 𝒩𝒫-hard, even if ks=1.

Proof.

We prove the claim by a reduction from Vertex Cover. Let I=(G,k) be an instance of Vertex Cover, where G=(V,E) is an undirected Graph and k is the required size of a vertex cover. We may assume that k<|V|=:n, otherwise I is trivial. We construct from I an instance I of P|and/or-prec,pj=1|γ with a single successor. We consider m:=n machines. The set J of jobs is composed of a job v for each vertex vV, a single job e, which will be the only successor and nk auxiliary jobs b1,,bnk. Through precedence constraints, we force all auxiliary jobs as well as one end-vertex per edge to be processed before e: We set

ψe=i=1nkxbi{v,w}E(xvxw)

and ψj=𝟙 for all jJ{e}. We require to find a feasible schedule 𝒮 with Cmax2 if γ=Cmax or jJCj3n2k+2 if γ=jCj. It is easy to see that I is a yes-instance precisely if we can find a schedule for I, which processes all auxiliary jobs and a vertex cover of size k during the first time slot and all remaining jobs during time slot two. The construction is visualized in Figure 3. From the proof of Proposition 11, we also get the following corollary:

Figure 3: Reduction of Vertex Cover with n=3 and k=1 to P|and/or-prec,pj=1|γ with ks=1.
Corollary 12.

P|and/or-prec,pj=1|Cmax is para-𝒩𝒫-hard, if parameterized by Cmax and ks.

5 Parameterization by the number of machines

A classical parameter in the study of parameterized complexity of scheduling problems, is the number of machines. In [4], Coffman and Graham prove that the 𝒩𝒫-hard problem P|prec,pj=1|Cmax becomes polynomial when restricted to two machines. For an arbitrary but constant number of machines, the complexity is open. However, Bodlaender and Fellows [2] prove that P|prec,pj=1|Cmax is W[2]-hard when parameterized by the number of machines. In the following, we prove that P2|and+or-prec,pj=1|γ is 𝒩𝒫-hard for γ{Cmax,jCj,jwjCj} and thus P|and+or-prec,pj=1|γ is para-𝒩𝒫-hard when parameterized by the number of machines. This result is also interesting in the context of the interplay between and- and or-constraints: On the one hand, it shows that the introduction of or-constraints turns the polynomial-time solvable P2|prec,pj=1|Cmax into an 𝒩𝒫-hard problem. On the other hand, the result below shows that the introduction of a single and-job turns the polynomial-time solvable P|or-prec,pj=1|Cmax into an 𝒩𝒫-hard problem. For an and+or-constrained instance with successors in Js=Jsor˙Jsand, we denote by ksand:=|Jsand| the number of and-successors.

Theorem 13.

P2|and+or-prec,pj=1|γ, γ{Cmax,jCj,jwjCj} with ksand=1 is 𝒩𝒫-hard.

Figure 4: Reduction from Vertex Cover to P2|and+or-prec,pj=1|γ with Jsand={b6}.

Proof.

We prove the claim by a reduction from Vertex Cover. Let I=(G,k) be an instance of Vertex Cover, where G=(V,E) is an undirected graph and k is the requested size of a vertex cover. We assume that k<|V|, otherwise I is trivial. We construct from I an instance I of P2|and+or-prec,pj=1|γ, γ{Cmax,jCj}, where the idea is the following: We introduce one job per edge, one job per vertex and :=|V|+|E| auxiliary jobs to block the second machine. Using precedence constraints, we will force a feasible schedule to process all jobs in a vertex cover of size at most k before finishing the edge jobs.

More precisely, we set J:=VEB where B={b1,,b} is the set of auxiliary jobs. All vertex jobs, as well as the first auxiliary job, may start at any time, i.e. ψj=𝟙 if jV{b1}. Edges may not be scheduled unless one of their end-vertices has been scheduled already, i.e. ψe=xuxv for e={u,v}E. We set

ψbk+|E|+1=xbk+|E|eExe

to make sure that all edge jobs have been scheduled by the time we start the (k+|E|+1)-st auxiliary job. To process all auxiliary jobs in a chain, we set ψbi=xbi1, i{2,,}{k+|E|+1}. Observe that Jsand:={bk+|E|+1} and Jsor:=E{b2,,bk+|E|,bk+|E|+2,,b} is a partition of the successors into or- and and-jobs. The construction is visualized in Figure 4. It is easy to see that I is a yes-instance, precisely if there exists a schedule for I with Cmax=, (jCj=(+1)).

6 Summary and Outlook

In this paper, we study the problems of minimizing the makespan and the sum of completion times in parallel machine scheduling of unit-time jobs under precedence constraints. In our setting, each job j is associated with a precedence constraint ψj, encoded as a Boolean formula over the set of jobs. A schedule satisfies ψj if setting exactly the jobs scheduled before j to true satisfies the formula. Depending on the structure of these formulas, we distinguish between and-, or-, and+or-, or/and-, and and/or-constraints.

To analyze the parameterized complexity of these problems, we introduce two new structural parameters: the total number of predecessors and the total number of successors. Restricting the number of predecessors yields fixed-parameter tractability, even for general precedence constraints. In contrast, restricting the number of successors leads to a more nuanced landscape: for traditional and-constraints and more general and+or-constraints, the problem is FPT, but for or/and-constraints (DNF), it becomes W[1]-hard. For and/or-constraints (CNF), the problem is even para-𝒩𝒫-hard. A common parameter in the analysis of scheduling problems is the number of machines. While minimizing the makespan for and-constrained unit jobs is known to be W[2]-hard parameterized by the number of machines (Bodlaender and Fellows [2]), we show that the same problem is para-𝒩𝒫-hard in the presence of and+or-constraints.

We believe these results open up several promising research directions. One such direction concerns the interplay between and- and or-constraints. Naturally, any known hardness result for problems with classical and-constraints carries over to the more general version of the problem with and+or-constraints. Conversely, certain or-constrained problems can be solved in polynomial time, while they are 𝒩𝒫-hard in the and-constrained version (Berit [11]). However, Theorem 13 shows that it is inaccurate to think that the hardness of and+or-constrained problems stems only from the and-constraints: While minimizing the makespan or sum of completion times for unit jobs on two machines is in 𝒫, both in the or- and the and-constrained version (Coffman and Graham [4], Berit [11]), we show that scheduling with and+or-constraints on just two machines is 𝒩𝒫-hard. We suggest studying parameters that measure the ratio between or- and and-constraints. In Theorem 13, we show that P2|and+or-prec,pj=1|Cmax is para-𝒩𝒫-hard parameterized by the number of and-successors, while Theorem 8 proves the same problem to be FPT parameterized by the total number of successors. Open questions in the same spirit include whether restricting only the predecessors of and-jobs or only the number of or-successors on two machines leads to tractability or retains hardness.

Table 1: Overview of parameterized complexity results for parallel machine scheduling of unit-time jobs with generalized precedence constraints.
Problem 𝜸 Parameter Complexity Source
P|gen-prec,pj=1|γ Cmax,jCj kp in 𝒫𝒯 Thm 2
P|gen-prec,pj=1|γ jwjCj kp in 𝒳𝒫 Thm 2
P|and+or-prec,pj=1|γ Cmax,jCj ks in 𝒫𝒯 Thm 8
P2|and+or-prec,pj=1|γ Cmax,jCj,jCj 𝒩𝒫-hard Thm 13
P|and+or-prec,pj=1|γ Cmax,jCj,jCj m, ksand para-𝒩𝒫-hard Thm 13
P|or/and-prec,pj=1|γ Cmax,jCj ks in 𝒳𝒫 Cor 5
P|or/and-prec,pj=1|γ Cmax,jCj,jwjCj ks W[1]-hard Thm 9
P|and/or-prec,pj=1|γ Cmax,jCj ks para-𝒩𝒫-hard Prop 11

Moreover, our results show that it is fruitful to explore parameters that limit job dependencies, especially for problems that become hard due to precedence constraints. This perspective contrasts with the focus on the width in classical and-constrained problems, which instead promotes high interrelatedness among jobs. In and-constrained problems, parameters of the precedence graph, which reduce interrelatedness, may include the size of a largest clique or tournament and the largest out- or in-degree. In particular, we propose a hybrid approach: combining parameters that limit the portion of input influenced by precedence constraints with parameters that enforce high interrelatedness within affected jobs.

References

  • [1] Stéphane Bessy and Rodolphe Giroudeau. Parameterized complexity of a coupled-task scheduling problem. Journal of Scheduling, 22(3):305–313, 2019. doi:10.1007/S10951-018-0581-1.
  • [2] Hans L Bodlaender and Michael R Fellows. W[2]-hardness of precedence constrained k-processor scheduling. Operations Research Letters, 18(2):93–97, 1995. doi:10.1016/0167-6377(95)00031-9.
  • [3] Lin Chen, Dániel Marx, Deshi Ye, and Guochuan Zhang. Parameterized and approximation results for scheduling with a low rank processing time matrix. In 34th Symposium on Theoretical Aspects of Computer Science (STACS 2017), pages 22–1. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2017. doi:10.4230/LIPIcs.STACS.2017.22.
  • [4] Edward G Coffman and Ronald L Graham. Optimal scheduling for two-processor systems. Acta informatica, 1:200–213, 1972. doi:10.1007/BF00288685.
  • [5] Thomas Erlebach, Vanessa Kääb, and Rolf H Möhring. Scheduling and/or-networks on identical parallel machines. In International workshop on approximation and online algorithms, pages 123–136. Springer, 2003. doi:10.1007/978-3-540-24592-6_10.
  • [6] Donald W Gillies and Jane W-S Liu. Scheduling tasks with and/or precedence constraints. SIAM Journal on Computing, 24(4):797–810, 1995. doi:10.1137/S0097539791218664.
  • [7] Michael Goldwasser, J-C Latombe, and Rajeev Motwani. Complexity measures for assembly sequences. In Proceedings of IEEE International Conference on Robotics and Automation, volume 2, pages 1851–1857. IEEE, 1996.
  • [8] Ronald L Graham. Bounds for certain multiprocessing anomalies. Bell system technical journal, 45(9):1563–1581, 1966.
  • [9] Ronald Lewis Graham, Eugene Leighton Lawler, Jan Karel Lenstra, and AHG Rinnooy Kan. Optimization and approximation in deterministic sequencing and scheduling: a survey. In Annals of discrete mathematics, volume 5, pages 287–326. Elsevier, 1979.
  • [10] Felix Happach. Makespan minimization with or-precedence constraints. Journal of Scheduling, 24(3):319–328, 2021. doi:10.1007/S10951-021-00687-6.
  • [11] Berit Johannes. On the complexity of scheduling unit-time jobs with or-precedence constraints. Operations research letters, 33(6):587–596, 2005. doi:10.1016/J.ORL.2004.11.009.
  • [12] Dušan Knop and Martin Kouteckỳ. Scheduling meets n-fold integer programming. Journal of Scheduling, 21:493–503, 2018. doi:10.1007/S10951-017-0550-0.
  • [13] Sanghyup Lee, Ilkyeong Moon, Hyerim Bae, and Jion Kim. Flexible job-shop scheduling problems with “AND”/“OR” precedence constraints. International Journal of Production Research, 50(7):1979–2001, 2012.
  • [14] Jan Karel Lenstra and AHG Rinnooy Kan. Complexity of scheduling under precedence constraints. Operations Research, 26(1):22–35, 1978. doi:10.1287/OPRE.26.1.22.
  • [15] Matthias Mnich and René Van Bevern. Parameterized complexity of machine scheduling: 15 open problems. Computers & Operations Research, 100:254–261, 2018. doi:10.1016/J.COR.2018.07.020.
  • [16] Matthias Mnich and Andreas Wiese. Scheduling and fixed-parameter tractability. Mathematical Programming, 154(1):533–562, 2015. doi:10.1007/S10107-014-0830-9.
  • [17] Rolf H Möhring, Martin Skutella, and Frederik Stork. Scheduling with and/or precedence constraints. SIAM Journal on Computing, 33(2):393–415, 2004. doi:10.1137/S009753970037727X.
  • [18] Jesper Nederlof and Céline M. F. Swennenhuis. On the Fine-Grained Parameterized Complexity of Partial Scheduling to Minimize the Makespan. In Yixin Cao and Marcin Pilipczuk, editors, 15th International Symposium on Parameterized and Exact Computation (IPEC 2020), volume 180 of Leibniz International Proceedings in Informatics (LIPIcs), pages 25:1–25:17, Dagstuhl, Germany, 2020. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.IPEC.2020.25.
  • [19] Damien Prot and Odile Bellenguez-Morineau. A survey on how the structure of precedence constraints may change the complexity class of scheduling problems. Journal of Scheduling, 21(1):3–16, 2018. doi:10.1007/S10951-017-0519-Z.
  • [20] Ravi Sethi. On the complexity of mean flow time scheduling. Mathematics of Operations Research, 2(4):320–330, 1977. doi:10.1287/MOOR.2.4.320.
  • [21] René Van Bevern, Robert Bredereck, Laurent Bulteau, Christian Komusiewicz, Nimrod Talmon, and Gerhard J Woeginger. Precedence-constrained scheduling problems parameterized by partial order width. In International conference on discrete optimization and operations research, pages 105–120. Springer, 2016. doi:10.1007/978-3-319-44914-2_9.