A Multivariate Complexity Analysis of the Material Consumption Scheduling Problem
Matthias Bentert, Robert Bredereck, Péter Györgyi, Andrzej Kaczmarczyk, Rolf Niedermeier
AA Multivariate Complexity Analysisof the Material Consumption Scheduling Problem
Matthias Bentert, Robert Bredereck,
1, 2
P´eter Gy¨orgyi, Andrzej Kaczmarczyk, and Rolf Niedermeier Technische Universit¨at Berlin, Faculty IV,Algorithmics and Computational Complexity, Berlin, Germany Humboldt-Universit¨at zu Berlin, Institut f¨ur Informatik, Algorithm Engineering, Berlin, Germany Institute for Computer Science and Control, Budapest, Hungary
March 1, 2021
Abstract
The NP-hard
Material Consumption Scheduling Problem and related problemshave been thoroughly studied since the 1980’s. Roughly speaking, the problem deals withminimizing the makespan when scheduling jobs that consume non-renewable resources. Wefocus on the single-machine case without preemption: from time to time, the resources ofthe machine are (partially) replenished, thus allowing for meeting a necessary pre-conditionfor processing further jobs, each of which having individual resource demands. We initiatea systematic exploration of the parameterized computational complexity landscape of theproblem, providing parameterized tractability as well as intractability results. Doing so, wemainly investigate how parameters related to the resource supplies influence the computa-tional complexity. Thereby, we get a deepened understanding of this fundamental schedulingproblem.
Keywords. non-renewable resources, parameterized computational complexity, fine-grainedcomplexity, exact algorithms
Consider the following motivating example. Every day, an agent works for a number of clients,all of equal importance. The clients, one-to-one corresponding to jobs, each time request a ser-vice having individual processing time and individual consumption of a non-renewable resource;examples for such resources include raw material, energy, and money. The goal is to finish alljobs as early as possible, known as minimizing the makespan in the scheduling literature. Un-fortunately, the agent only has a limited initial supply of the resource which is to be renewed(with potentially different amounts) at known points of time during the day. Since the job char-acteristics (resource consumption, job length) and the resource delivery characteristics (deliveryamount, point of time) are known in advance, the objective thus is to find a feasible job scheduleminimizing the makespan. Notably, jobs cannot be preempted and only one at a time can be1 a r X i v : . [ c s . G T ] F e b j a j u (cid:96) b (cid:96) tu u u u C max = 12 J J J J J J Figure 1: An example (left) with one resource type and a solution (right) with makespan 12.The processing times and the resource requirements are in the first table, while the supply datesand the supplied quantities are in the second. Note that J and J consume all of the resourcessupplied at u = 0, thus we have to wait for the next supply to schedule further jobs.executed. Figure 1 provides a concrete numerical example with six jobs with varying job lengthsand resource requirements.The described problem setting is known as minimizing the makespan on a single machinewith non-renewable resources. Notably, in our example we considered the special but perhapsmost prominent case of just one type of resource. More specifically, we study the single-machinevariant of the NP-hard Material Consumption Scheduling Problem . Formally, we have aset R of resources and a set J = { J , . . . , J n } of jobs to be scheduled on a single machine withoutpreemption. The machine can process at most one job at a time. Each job has a processing time p j ∈ Z + and a resource requirement a ij ∈ Z + from resource i ∈ R . We have resource suppliesat q different points of time 0 = u < u < · · · < u q , where the vector ˜ b (cid:96) = (˜ b i,(cid:96) ) i ∈R ∈ Z |R| + represents the quantities supplied at time u (cid:96) . The starting time S j for each job J j is specifiedby a schedule σ , which is feasible if (i) the jobs do not overlap in time, and (ii) at any pointof time t the total supply from each resource is at least the total request of the jobs startinguntil t , that is, (cid:88) (cid:96) : u (cid:96) ≤ t ˜ b i,(cid:96) ≥ (cid:88) j : S j ≤ t a ij , ∀ i ∈ R . Note that in case of just one resource type (as in our starting example in Figure 1), wesimply drop the indices corresponding to the single resource. The objective is to minimize themaximum job completion time (makespan) C max := max j ∈J C j , where C j is the completion timeof job J j . In the remainder of the paper, we make the following simplifying assumptions (whichcan be easily achieved) guaranteeing sanity of the instances and filtering out trivial cases. Assumption 1.
Without loss of generality, we assume that1. there are enough resources supplied to process all jobs: (cid:80) q(cid:96) =1 ˜ b (cid:96) ≥ (cid:80) j ∈J a j ;2. each job has at least one non-zero resource requirement: ∀ j ∈J (cid:80) i ∈R a i,j > ; and3. at least one resource unit is supplied at time : (cid:80) i ∈R ˜ b i, > . The
Material Consumption Scheduling Problem is NP-hard even in case of one ma-chine, only two supply dates ( q = 2), and if the processing time of each job is the same as itsresource requirement, that is, p j = a j , ∀ j ∈ J [9]. While many variants of the Material Con-sumption Scheduling Problem have been studied in the literature in terms of heuristics,polynomial-time approximation algorithms, or the detection of polynomial-time solvable special2ases, we are not aware of any previous systematic studies concerning a multivariate complexityanalysis. In other words, we study, seemingly for the first time, several natural problem-specificparameters and investigate how they influence the computational complexity of the problem. Do-ing so, we prove both parameterized hardness as well as encouraging fixed-parameter tractabilityresults for this NP-hard problem.
Related Work.
Over the years, performing multivariate, parameterized complexity studiesfor fundamental scheduling problems became more and more popular [2, 4, 5, 6, 7, 19, 16, 29,30, 31, 33, 32, 37, 40, 41]. We contribute to this field by a seemingly first-time explorationof the
Material Consumption Scheduling Problem , focusing on one machine and theminimization of the makespan.The problem was introduced in the 1980’s [9, 43]. Indeed, even a bit earlier a problem wherethe jobs required non-renewable resources, but without any machine environment, was stud-ied [10]. The problem appears in several real-world applications, for instance, in the continuouscasting stage of steel production [34], in managing deliveries by large-scale distributors [1], or inshoe production [11].Carlier [9] proved several complexity results for different variants in the single-machinecase, while Slowinski [43] studied the parallel machine variant of the problem with preemp-tive jobs. Previous theoretical results mainly concentrate on the computational complexity andpolynomial-time approximability of different variants; in this literature review we mainly focuson the most important results for the single-machine case and minimizing makespan as theobjective. We remark that there are several recent results for variants with other objectivefunctions [3, 27, 28], with a more complex machine environment [26], and with slightly differentresource constraints [14].Toker et al. [44] proved that the variant where the jobs require one non-renewable resourcereduces to the provided that the single non-renewable re-source has a unit supply in every time period. Later, Xie [45] generalized this result to multipleresources. Grigoriev et al. [21] showed that the variant with unit processing times and two re-sources is NP-hard, and they also provided several polynomial-time 2-approximation algorithmsfor the general problem. There is also a polynomial-time approximation scheme (PTAS) for thevariant with one resource and a constant number of supply dates and a fully polynomial-timeapproximation scheme (FPTAS) for the case with q = 2 supply dates and one non-renewableresource [23]. Gy¨orgyi and Kis [24] presented approximation-preserving reductions betweenproblem variants in case of q = 2 and variants of the Multidimensional Knapsack Prob-lem . These reductions have several consequences, for example, it was shown that the problemis NP-hard if there are two resources, two supply dates, and each job has a unit processing time,or that there is no FPTAS for the problem with two non-renewable resources and q = 2 supplydates, unless P = NP. Finally, there are three further results [25]: (i) a PTAS for the variantwhere the number of resources and the number of supply dates are constants; (ii) a PTAS forthe variant with only one resource and an arbitrary number of supply dates if the resource re-quirements are proportional to job processing times; and (iii) APX-hardness when the numberof resources is part of the input. Preliminaries and Notation.
We use the standard three field α | β | γ -notation [20], where α denotes the machine environment, β the further constraints like additional resources, and γ the objective function. We always consider a single machine, that is, there is a 1 in the α field.3he non-renewable resources are described by nr in the β field and nr = r means that there are r different resource types. In our work, the only considered objective is the makespan C max . Forexample, the Material Consumption Scheduling Problem variant with a single machine,single resource type, and with the makespan as the objective is expressed as 1 | nr = 1 | C max .We also sometimes consider the so-called non-idling scheduling (introduced by Chr´etienne [12]),indicated by NI in the α field, in which a machine can only process all jobs continuously, withoutintermediate idling. As we make the simplifying assumption that the machine has to startprocessing jobs at time 0, we drop the optimization goal C max whenever considering non-idlingscheduling. When there is just one resource (nr = 1), then we write a j instead of a ,j and ˜ b j instead of ˜ b ,j , etc. We also write p j = 1 or p j = ca j whenever, respectively, jobs have solelyunit processing times or the resource requirements are proportional to the job processing times.Finally, we use “unary” to indicate that all numbers in an instance are encoded in unary. Thus,for example, 1 , NI | p j = 1 , unary |− denotes a single non-idling machine, unit-processing-timejobs and the unary encoding of all numbers. We summarize the notation of the parameters thatwe consider below. n number of jobs q number of supply dates j job index (cid:96) index of a supply p j processing time of job ja i,j resource requirement of job j from resource iu (cid:96) the (cid:96) th supply date˜ b i,(cid:96) quantity supplied from resource i at u (cid:96) b i,(cid:96) total resource supply from resource i over the first (cid:96) supplies, that is, (cid:80) (cid:96)k =1 ˜ b i,k To simplify matters, we introduce the shorthands a max , b max , and p max for max j ∈J ,i ∈R a ij ,max (cid:96) ∈{ ,...,q } ,i ∈R ˜ b i,(cid:96) , and max j ∈J p j , respectively. Primer on Multivariate Complexity.
To analyze the parameterized complexity [13, 15, 17,42] of the
Material Consumption Scheduling Problem , we declare some part of the inputthe parameter (e.g., the number of supply dates). A parameterized problem is fixed-parametertractable if it is in the class
FPT of problems solvable in f ( ρ ) · | I | O (1) time, where | I | is the sizeof a given instance encoding, ρ is the value of the parameter, and f is an arbitrary computable(usually super-polynomial) function. Parameterized hardness (and completeness) is definedthrough parameterized reductions similar to classical polynomial-time many-one reductions. Forour work, it suffices to additionally ensure that the value of the parameter in the problem wereduce to depends only on the value of the parameter of the problem we reduce from. To obtainparameterized intractability, we use parameterized reductions from problems of the class W[1]which is widely believed to be a proper superclass of FPT .The class XP contains all problems that can be solved in | I | f ( ρ ) time for a function f solely de-pending on the parameter ρ . While XP ensures polynomial-time solvability when ρ is a constant, FPT additionally ensures that the degree of the polynomial is independent of ρ . Unless P = NP ,membership in XP can be excluded by showing that the problem is NP -hard for a constantparameter value (for short, we say the problem is para- NP -hard).4 b max u max a max a max + q | nr = 1 , p j = 1 | C max P ‡ | nr = 1 , p j = ca j | C max W[1]-h (cid:5) , XP ♣ p-NP-h (cid:4) FPT ♦ XP (cid:78) FPT † | nr = 1 , unary | C max W[1]-h (cid:5) , XP ♣ p-NP-h (cid:4) FPT ♦ XP (cid:78) FPT † | nr = 2 , p j = 1 , unary | C max W[1]-h ♥ , XP ♣ p-NP-h (cid:4) XP ♣ open FPT ♠ | nr = const , unary | C max W[1]-h ♥ , XP ♣ p-NP-h (cid:4) XP ♣ open FPT ♠ | nr , p j = 1 | C max p-NP-h (cid:72) p-NP-h (cid:72) W[1]-h (cid:72) p-NP-h (cid:72)
W[1]-h (cid:72)
Table 1: Our results for a single resource type (top) and multiple resource types (bottom). Theresults correspond to Theorem 3 ( ‡ ), Theorem 4 ( ♦ ), Theorem 2 ( (cid:5) ), Theorem 1 ( (cid:4) ), Gy¨orgyiand Kis [23] ( ♣ ), Proposition 1 ( ♥ ), Proposition 2 ( ♠ ), Theorem 5 ( † ), Theorem 6 ( (cid:78) ), andTheorem 7 ( (cid:72) ). W[1]-h and p-NP-h stand for, respectively, W[1]-hard and para- NP -hard. Our Contribution.
Most of our results are summarized in Table 1. We focus on the param-eterized computational complexity of the
Material Consumption Scheduling Problem with respect to several parameters describing resource supplies. We show that the case of asingle resource and jobs with unit processing time is polynomial-time solvable. However, if eachjob has a processing time proportional to its resource requirement, then the
Material Con-sumption Scheduling Problem becomes NP-hard even for a single resource and when eachsupply provides one unit of the resource. Complementing an algorithm solving the
MaterialConsumption Scheduling Problem in polynomial time for a constant number q of supplydates, we show, by proving W[1]-hardness, that the parameterization by q presumably does notyield fixed-parameter tractability. We circumvent the W[1]-hardness by combining the param-eter number q of supply dates with the maximum resource requirement a max of a job, therebyobtaining fixed-parameter tractability for the combined parameter q + a max . Moreover, we showfixed-parameter tractability for the parameter u max that denotes the last resource supply time.Finally, we provide an outlook on cases with multiple resources and show that fixed-parametertractability for q + a max extends when we additionally add the number of resources r to thecombined parameter, that is, we show fixed-parameter tractability for q + a max + r . For the Material Consumption Scheduling Problem with an unbounded number of resources,we show intractability even for the case where all other previously discussed parameters arecombined.
We start our investigation on the computational complexity of the
Material ConsumptionScheduling Problem with outlining the limits of efficient computability. Setting up clearborders of tractability, we identify potential scenarios suitable for seeking efficient solutions.This approach seems especially justified because the
Material Consumption SchedulingProblem is already NP-hard for the quite constrained scenario of unit processing times andtwo resources [21].Both hardness results in this section use reductions from
Unary Bin Packing . Given anumber k of bins, a bin size B , and a set O = { o , o , . . . o n } of n objects of sizes s , s , . . . s n (encoded in unary), Unary Bin Packing asks to distribute the objects to the bins such thatno bin exceeds its capacity.
Unary Bin Packing is NP -hard and W[1]-hard parameterized by5 ∗ J = (8 , J = (24 , J = (16 , J = (16 , Unary Bin Packing consisting of k = 2 bins each of size B = 4 and four objects o to o of sizes s = 1, s = s = 2,and s = 3. In the resulting instance of 1 | nr = 1 , p j = ca j | C max , there are five jobs ( J ∗ andone job corresponding to each input object) and in each (whole) point in time in the hatchedperiods there is a supply of one resource. An optimal schedule that first schedules J ∗ is depicted.Notice that the time periods between the (right-hand) ends of hatched periods correspond to amultiple of the bin size and a schedule is gapless if and only if the objects corresponding to jobsscheduled between the ends of two consecutive shaded areas exactly fill a bin.the number k of bins even if (cid:80) ni =1 s i = kB [35].We first focus on the case of a single resource, for which we find a strong intractability result.In the following theorem, we show that even if each supply comes with a single unit of a resource,then the problem is already NP-hard. Theorem 1. | nr = 1 , p j = ca j | C max is para- NP -hard with respect to the maximum number b max of resources supplied at once even if all numbers are encoded in unary.Proof. Given an instance I of Unary Bin Packing with (cid:80) ni =1 s i = kB , we construct aninstance I (cid:48) of 1 | nr = 1 | C max with b max = 1 as described below.We define n jobs J = ( p , a ) , J = ( p , a ) , . . . , J n = ( p n , a n ) such that p i = 2 Bs i and a i = 2 s i . We also introduce a special job J ∗ = ( p ∗ , a ∗ ), with p ∗ = 2 B and a ∗ = 1. Then, we set2 kB supply dates as follows. For each i ∈ { , , . . . , k − } and x ∈ { , , . . . , B − } , we createa supply date q xi = ( u xi , ˜ b xi ) := ((2 B + i B ) − x, q ∗ := (0 , I is a yes-instance if and only if there is a gapless schedule for I (cid:48) , thatis, C max = 2( B + B ). An example of this construction is depicted in Figure 2.We first show that each solution to I can be efficiently transformed to a schedule with C max =2( B + B ). A yes-instance for I is a partition of the objects into k bins such that each binis (exactly) full. Formally, there are k sets S , S , . . . S k such that (cid:83) i S i = O , S i ∩ S j = ∅ for all i (cid:54) = j , and (cid:80) o i ∈ S j s i = B for all j . We form a schedule for I (cid:48) as follows. First, weschedule job j ∗ and then, continuously, all jobs corresponding to elements of set S , S , andso on. The special supply q ∗ guarantees that the resource requirement of job j ∗ is met attime 0. The remaining jobs, corresponding to elements of the partitions, are scheduled earliestat time 2 B , when j ∗ is processed. The jobs representing each partition, by definition, requirein total 2 B resources and take, in total, 2 B time. Thus, it is enough to ensure that in eachpoint 2 B + i B , for i ∈ { , , . . . , k − } , there are at least 2 B resources available. This is truebecause, for all i ∈ { , , . . . , k − } , every time 2 B + iB when there is a supply of a singleresource is preceded with 2 B − B . As a result, the schedule is feasible.Now we show that a gapless schedule for I (cid:48) implies that I is a yes-instance. Let S be agapless schedule for I (cid:48) . Observe that all processing times are multiples of 2 B and therefore eachjob has to start at a time that is a multiple of 2 B . For each i ∈ { , , . . . , k − } , we show6hat there is no job that is scheduled to start before 2 B + iB and to end after this time. Weshow this by induction on i . Since at time 0 there is only one resource available, job J ∗ (withprocessing time 2 B ) must be scheduled first. Hence the statement holds for i = 0. Assumingthat the statement holds for all i < i (cid:48) for some i (cid:48) , we show that it also holds for i (cid:48) . Assumetowards a contradiction that there is a job J that starts before t := 2 B + i (cid:48) B and ends afterthis time. Let S be the set of all jobs that were scheduled to start between t := 2 B + ( i (cid:48) − B and t . Recall that for each job J j (cid:48) ∈ S , we have that p j (cid:48) = a j (cid:48) B . Hence, since J ends after t , thenumber of resources used by S is larger than ( t − t ) / B = B . Since only 2 B resources are availableat time t , job J cannot be scheduled before time t or there is a gap in the schedule (such a gapwould allow to use some of the 2 B resources supplied in the 2 B time units just before time t ),a contradiction. Hence, there is no job that starts before t and ends after it. Thus, the jobs canbe partitioned into “phases,” that is, there are k + 1 sets T , T , . . . , T k such that T = { J ∗ } , (cid:83) h> T h = J \ { J ∗ } , T h ∩ T j = ∅ for all h (cid:54) = j , and (cid:80) J j ∈ T g p j = 2 B for all g . This correspondsto a bin packing where o g belongs to bin h > J g ∈ T h .Note that Theorem 1 excludes pseudopolynomial algorithms for the case under considerationsince the theorem statement is true also when all numbers are encoded in unary.Theorem 1 motivates to study further problem-specific parameters. Observe that in thereduction presented in the proof of Theorem 1, we used an unbounded number of supply dates.Gy¨orgyi and Kis [23] have shown a pseudopolynomial algorithm for 1 | nr = 1 | C max for thecase that the number q of supplies is a constant. Thus, the question is whether we can evenobtain fixed-parameter tractability for our problem by taking the number of supply dates as aparameter. Devising a reduction from Unary Bin Packing , we answer this question negativelyin the following theorem.
Theorem 2. | nr = 1 , p j = a j | C max parameterized by the number of supply dates is W[1] -hardeven if all numbers are encoded in unary.Proof.
We reduce from
Unary Bin Packing parameterized by the number k of bins, which isknown to be W[1]-hard [35]. Given an instance I of Unary Bin Packing with k bins, each ofsize B and n objects o , o , . . . o n of size s , s , . . . s n such that (cid:80) ni =1 s i = kB , we construct aninstance I (cid:48) of 1 | nr = 1 | C max as follows. We denote the set of all objects by O .First, for each o i ∈ O , we define a job J i = ( p i , a i ) such that p i = a i = s i ; we denote the setof all jobs by J . Next, we construct k supply dates q i = ( u i , ˜ b i ), with u i = ( i − B and ˜ b i = B for each i ∈ [ k ]. This way we obtain an instance I (cid:48) of 1 | nr = 1 | C max .It remains to show that I is a yes-instance if and only if I (cid:48) is an instance with C max = kB .To this end, suppose first that I is a yes-instance. Then, there is a partition of the objectsinto k bins such that each bin is (exactly) full. Formally, there are k sets S , S , . . . S k suchthat (cid:83) i S i = O , S i ∩ S j = ∅ for all i (cid:54) = j , and (cid:80) o i ∈ S j s i = B for all j . Hence we scheduleall jobs j i with o i ∈ S between time 0 = u and B = u . Following the same procedure, weschedule all jobs corresponding to objects in S i between time u i and u i +1 where u i +1 = iB .Since (cid:80) ni =1 p i = kB , we conclude that C max = kB .Now suppose that C max = kB . Assume towards a contradiction that there is an optimalschedule in which some job J i ∈ J starts at some time t such that t < u (cid:96) < t + p i for some (cid:96) ∈ [ k ].Let S be the set of all objects that are scheduled before J i . Since C max = kB , it follows that ateach point in time until t , there is some job scheduled at this time. Thus, since p h = a h for alljobs J h , it follows that (cid:80) J h ∈ S a h = (cid:80) J h ∈ S p h = t . As a result, (cid:80) J h ∈ S ∪{ J i } a h = t + a i = t + p i >u (cid:96) = ( (cid:96) − B = (cid:80) (cid:96) − h =1 ˜ b h ; a contradiction to j i starting before u (cid:96) . Hence, there is no job that7tarts before some u (cid:96) and ends after it. Thus, the jobs can be partitioned into “phases,” that is,there are k sets T , T , . . . , T k such that (cid:83) h T h = J , T i ∩ T i (cid:48) = ∅ for all i (cid:54) = i (cid:48) , and (cid:80) J h ∈ T g p h = B for all g . This corresponds to a bin packing where o g belongs to bin h if and only if J g ∈ T h .The theorems presented in this section show that our problem is (presumably) not fixed-parameter tractable either with respect to the number of supply dates or with respect to themaximum number of resources per supply. However, as we show in the following section, com-bining these two parameters allows for fixed-parameter tractability. Furthermore, we presentother algorithms that, partially, allow us to successfully evade the hardness presented above. Our search for efficient algorithms for our variant of the
Material Consumption SchedulingProblem starts with an introductory part presenting two lemmata exploiting structural prop-erties of problem solutions. Afterwards, we employ the lemmata and provide several tractabilityresults, including polynomial-time solvability for one specific case.
A solution to the
Material Consumption Scheduling Problem is an ordered list of jobs tobe executed on the machine(s). Additionally, the jobs need to be associated with their startingtimes. The starting times have to be chosen in such a way that no job starts when the machineis still processing another scheduled job and that each job requirement is met at the momentof starting the job. We show that, in fact, given an order of jobs, one can always compute thetimes of starting the jobs minimizing the makespan in polynomial time. Formally, we presentin Lemma 1 a polynomial-time Turing reduction from 1 | nr = r | C max to 1 , NI | nr = r |− . Thecrux of this lemma is to observe that there always exists an optimal solution to 1 | nr = r | C max that is decomposable into two parts. First, when the machine is idling, and second, when themachine is continuously busy until all jobs are processed. Lemma 1.
There is a polynomial-time Turing reduction from | nr = r | C max to , NI | nr = r |− .Proof. Assuming that we have an oracle for 1 , NI | nr = r |− , we describe an algorithm solv-ing 1 | nr = r | C max that runs in polynomial time.We first make a useful observation about feasible solutions to the original problem. Let usconsider some feasible solution σ to 1 | nr = r | C max and let g , g , . . . , g n be idle times beforeprocessing, respectively, jobs J , J , . . . , J n . Then, σ can be transformed to another schedule σ (cid:48) with the same makespan as σ and with idle times g (cid:48) , g (cid:48) , . . . , g (cid:48) n such that g (cid:48) = g (cid:48) . . . g (cid:48) n = 0and g (cid:48) = (cid:80) t ∈ [ n ] g t . Intuitively, σ (cid:48) is a scheduling in which the idle times of σ are all “moved”before the machine starts the first scheduled job. It is straightforward to see that in σ (cid:48) no jobsare overlapping. Furthermore, each job according to σ (cid:48) is processed at earliest at the same timeas it is processed according to σ . Thus, because there are no “negative” supplies and the order ofprocessed jobs is the same in both σ and σ (cid:48) , each job’s resource request is met in scheduling σ (cid:48) .Using the above observation, the algorithm solving 1 | nr = r | C max using an oracle for1 , NI | nr = r |− problem works as follows. First, it guesses a starting gap’s duration g ≤ u max and then calls an oracle for 1 , NI | nr = r |− subtracting g from each supply time (and merging all8on-positive supply times to a new one arriving at time zero) of the original 1 | nr = r | C max in-stance. For each value of g the algorithm adds g to the oracle’s output and returns the minimumover all these sums.Basically, the algorithm finds a scheduling with the smallest possible makespan assumingthat the idle time happens only before the first scheduled job is processed. Thus, due to theinitial observation that every schedule can be transferred to a same-makespan schedule that hasonly the initial idle time, the algorithm is correct. Because of the monotonicity of the makespanwith respect to the initial idle time g , the algorithm can perform binary search while searchingfor g and thus its running time is O (log( u max )).Let us further explain the crucial observation backing Lemma 1 since we will extend itin the subsequent Lemma 2. Assume that, for some instance of the Material ConsumptionScheduling Problem , there is some optimal schedule where some job J starts being processedat some time t (in particular, the resource requirements of J are met at t ). If, directly after thejob the machine idles for some time, then we can postpone processing J to the latest momentwhich still guarantees that J is ended before the next job is processed. Naturally, in any case,at the new starting time of J we can only have more resources than at the old starting time.Applying this observation exhaustively produces a solution that is clearly separated into idlingtime and busy time.We will now further exploit the observation of the previous paragraph beyond only “moving”jobs without changing their mutual order. We first define a domination relation over jobs;intuitively, a job dominates another job if it is not shorter and at the same time it requires notmore resources. Definition 1.
A job J j dominates a job J j (cid:48) (written J j ≤ D J j (cid:48) ) if p j ≥ p j (cid:48) and a i,j ≤ a i,j (cid:48) forall i ∈ R .When we deal with non-idling schedules, for a pair of jobs J j and J j (cid:48) where J j dominates J j (cid:48) ,it is better (or at least not worse) to schedule J j before J j (cid:48) . Indeed, since among these two, J j ’srequirements are not greater and its processing time is not smaller, surely after the machinestops processing J j there will be at least as many resources available as if the machine hadprocessed J j (cid:48) . We formalize this observation in the following lemma. Lemma 2.
For an instance of , NI | nr |− let < D be an asymmetric subrelation of ≤ D . Therealways exists a feasible schedule where for every pair J j and J j (cid:48) of jobs it holds that if J j < D J j (cid:48) ,then J j is processed before J j (cid:48) .Proof. Let σ be some feasible schedule. Consider a pair ( J j , J j (cid:48) ) of jobs such that J j is scheduledafter J j (cid:48) and J j dominates J j (cid:48) , that is, p j ≥ p j (cid:48) , a ij ≤ a ij (cid:48) for all i ∈ R . Let us denote by σ (cid:48) a schedule emerging from continuously scheduling all jobs in the same order as in σ but withjobs J j and J j (cid:48) swapped. Assume that σ (cid:48) is not a feasible schedule. We show that each job in σ (cid:48) meets its resource requirements thus contradicting the assumption and proving the lemma. Wedistinguish between the set of jobs J out that are scheduled before J j (cid:48) in σ or that are scheduledafter J j in σ and jobs J in that are scheduled between j (cid:48) and j in σ (including j (cid:48) and j ). Observethat since all jobs in J in are scheduled without the machine idling, it holds that all jobs in J out are scheduled exactly at the same times in both σ and σ (cid:48) . Additionally, since the total numberof resources consumed by jobs in J in in both σ and σ (cid:48) is the same, the resource requirements foreach job in J out is met in σ (cid:48) . It remains to show that the requirements of all jobs in J in are stillmet after swapping. To this end, observe that all jobs except for J j (cid:48) still meet the requirements9n σ (cid:48) as J j dominates J j (cid:48) (i.e., J j requires at most as many resources and has at least the sameprocessing time as J j (cid:48) ). Thus, each job in J in except for J j (cid:48) has at least as many resourcesavailable in σ (cid:48) as they have in σ . Observe that J j (cid:48) is scheduled later in σ (cid:48) as J j was scheduledin σ . Hence, there are also enough resources available in σ (cid:48) to process J j (cid:48) . Thus, σ (cid:48) is feasible,a contradiction.Note that in the case of two jobs J j and J j (cid:48) dominating each other (i.e., J j ≤ D J j (cid:48) and J j (cid:48) ≤ D J j ), Lemma 2 allows for either of them to be processed before the other one. We start with a polynomial-time algorithm that applies both Lemma 1 and Lemma 2 to solve aspecific case of the
Material Consumption Scheduling Problem where each two jobs canbe compared according to the domination relation (Definition 1). Recall that if this is the case,then Lemma 2 almost exactly specifies the order in which the jobs should be scheduled.
Theorem 3. , NI | nr |− and | nr | C max are solvable in, respectively, cubic and quadratic time ifthe domination relation is a weak order on a set of jobs. In particular, for the time u max of thelast supply, | nr = 1 , p j = 1 | C max and | nr = 1 , a j = 1 | C max are solvable in O ( n log n log u max ) time and , NI | nr = 1 , p j = 1 |− and , NI | nr = 1 , a j = 1 |− are solvable in O ( n log n ) time.Proof. We first show how to solve 1 , NI | nr = 1 , p j = 1 |− . At the beginning, we order the jobsincreasingly with respect to their requirements of the resource arbitrarily ordering jobs withequal requirements. Then, we simply check whether scheduling the jobs in the computed orderyields a feasible schedule, that is, whether the resource requirement of each job is met. If thecheck fails, we return “no,” otherwise we report “yes.” The algorithm is correct due to Lemma 2which, adapted to our case, says that there must exist an optimal schedule in which jobs withsmaller resource requirements are always processed before jobs with bigger requirements. It isstraightforward to see that the presented algorithm runs in O ( n log n ) time.To extend the algorithm to 1 | nr = 1 , p j = 1 | C max , we apply Lemma 1. As described indetail in the proof of Lemma 1, we first guess the idling-time g of the machine at the beginning.Then, we run the algorithm for 1 , NI | nr = 1 , p j = 1 |− pretending that we start at time g byshifting backwards by g the times of all resource supplies. Since we can guess g using binarysearch in a range from 0 to the time of the last supply, such an adaptation adds a multiplicativefactor of O (log u max ) to the running time of the algorithm for 1 , NI | nr = 1 , p j = 1 |− . Thecorrectness of the algorithm follows immediately from the proof of Lemma 1.The proofs for 1 | nr = 1 , p j = 1 |− and 1 | nr = 1 , a j = 1 | C max as well as the algorithms forthese problems are analogous to those of 1 | nr = 1 , p j = 1 |− and 1 | nr = 1 , p j = 1 | C max .The aforementioned algorithms need only a small modification to work for the cases of 1 | nr |− and 1 | nr | C max in which the domination relation is a weak order on a set of jobs. Namely, insteadof sorting the jobs, one needs to find a weak order over the jobs. This is doable in quadratictime by comparing all pairs of the jobs followed by checking whether the comparisons induce aweak order; thus we obtain the claimed running time. The obtained algorithm is correct by thesame argument as the other above-mentioned cases.Importantly, it is simple (requiring at most O ( n ) comparisons) to identify the cases forwhich the above algorithm can be applied successfully.10f the given jobs cannot be weakly ordered by domination, then the problem becomes NP-hard as shown in Theorem 1. This is to be expected since when jobs appear which are in-comparable with respect to domination, then one cannot efficiently decide which job, out oftwo, to schedule first: the one which requires fewer resource units but has a shorter processingtime, or the one that requires more resource units but has a longer processing time. Indeed, itcould be the case that sometimes one may want to schedule a shorter job with smaller resourceconsumption to save resources for later, or sometimes it is better to run a long job consum-ing, for example, all resources knowing that soon there will be another supply with sufficientresource units. Since NP-hardness presumably excludes polynomial-time solvability, we turn toa parameterized complexity analysis to get around the intractability.The time u max of the last supply seems a promising parameter. We show that it yieldsfixed-parameter tractability. Intuitively, we demonstrate that the problem is tractable when thetime until all resources are available is short. Theorem 4. , NI | nr = 1 | C max parameterized by the time u max of the last supply is fixed-parameter tractable and can be solved in O (2 u max · n + n log n ) time.Proof. We first sort all jobs by their processing time in O ( n ) time using bucket sort. We thensort all jobs with the same processing time by their resource requirement in overall O ( n log n )time. We then iterate over all subsets R of { , , . . . , u max } . We will refer to the elements in R by r , r , . . . , r k , where k = | R | and r i < r j for all i < j . For simplicity, we will use r = 0.For each r i in ascending order, we check whether there is a job with a processing time r i − r i − that was not scheduled before and if so, then we schedule the respective job that is first in eachbucket (the job with the lowest resource requirement). Next, we check whether there is a jobleft that can be scheduled at r k and which has a processing time at least u max − r k . Finally,we schedule all remaining jobs in an arbitrary order and check whether the total number ofresources suffices to run all jobs.We will now prove that there is a valid gapless schedule if and only if all of these checks aremet. Notice that if all checks are met, then our algorithm provides a valid gapless schedule. Nowassume that there is a valid gapless schedule. We will show that our algorithm finds a (possiblydifferent) valid gapless schedule. Let, without loss of generality, J j , J j , . . . , J j n be a valid gaplessschedule and let j k be the index of the last job that is scheduled latest at time u max . We nowfocus on the iteration where R = { , p j , p j + p j , . . . , (cid:80) ki =1 p j i } . If the algorithm schedules thejobs J j , J j , . . . , J j k , then it computes a valid gapless schedule and all checks are met. Otherwiseit schedules some jobs differently but, by construction, it always schedules a job with processingtime p j i at position i ≤ k . Due to Lemma 2 the schedule computed by the algorithm is alsovalid. Thus the algorithm computes a valid gapless schedule and all checks are met.It remains to analyze the running time. The sorting steps in the beginning take O ( n log n )time. There are 2 u max iterations for R , each taking O ( n ) time. Indeed, we can check in constanttime for each r i which job to schedule and this check is done at most n times (as afterwards thereis no job left to schedule). Searching for the job that is scheduled at time r k also takes O ( n )time as we can iterate over all remaining jobs and check in constant time whether it fulfills bothrequirements.Another possibility for fixed-parameter tractability via parameters measuring the resourcesupply structure comes from combining the parameters q and b max . Although both parametersalone yield intractability, combining them gives fixed-parameter tractability in an almost trivialway: By Assumption 1, every job requires at least one resource so b max · q is an upper bound11or the number of jobs. Hence, with this parameter combination, we can try out all possibleschedules without idling (which by Lemma 1 extends to solving to 1 , NI | nr = 1 | C max ).Motivated by this, we replace the parameter b max by the presumably much smaller (andhence practically more useful) parameter a max . We consider scenarios with only few resourcesupplies and jobs that require only small units of resources as practically relevant.Next, Theorem 5 employs the technique of Mixed Integer Linear Programming (MILP) [8]to positively answer the question of fixed-parameter tractability for the combined parameter q + a max . Theorem 5. , NI | nr = 1 | C max is fixed-parameter tractable for the combined parameter q + a max ,where q is the number of supplies and a max is the maximum resource requirement per job.Proof. Applying the famous theorem of Lenstra [39], we describe an integer linear programthat uses only f ( q, a max ) integer variables. Lenstra [39] showed that an (mixed) integer linearprogram is fixed-parameter tractable when parameterized by the number of integer variables (seealso Frank and Tardos [18] and Kannan [36] for later improvements). To significantly simplifythe description of the integer program, we use an extension to integer linear programs thatallows concave transformations on variables [8].Our approach is based on two main observations. First, by Lemma 2 we can assume thatthere is always an optimal schedule that is consistent with the domination order. Second,within a phase (between two resource supplies), every job can be arbitrarily reordered. Roughlyspeaking, a solution can be fully characterized by the number of jobs that have been started foreach phase and each resource requirement.We use the following non-negative integer variables:1. x w,s denoting the number of jobs requiring s resources started in phase w ,2. x Σ w,s denoting the number of jobs requiring s resources started in all phases between 1and w (inclusive),3. α w denoting the number of resources available in the beginning of phase w ,4. d w denoting the endpoint of phase w , that is, the time when the last job started in phase w ends.Naturally, the objective is to minimize d q .First, we ensure that x Σ w,s are correctly computed from x w,s by adding: x Σ w,s = (cid:80) ww (cid:48) =1 x w (cid:48) ,s Second, we ensure that all jobs are scheduled sometime. To this end, using s to denote thenumber of jobs J j with resource requirement a j = s we add: ∀ s ∈ [ a max ] : (cid:80) w ∈ [ q ] x w,s = s . Third, we ensure that the α w variables are set correctly, by setting α = ˜ b , and ∀ ≤ w ≤ q : α w = α w − + ˜ b w − (cid:80) s ∈ [ a max ] x w − ,s · s. Fourth, we ensure that we always have enough resources: ∀ ≤ w ≤ q : α w ≥ ˜ b w . Next, we compute the endpoints d w of each phase, assuming a schedulerespecting the domination order. To this end, let p s , p s , . . . , p s s denote the processing timesof jobs with resource requirement exactly s in decreasing order. Further, let τ s ( y ) denote theprocessing time spent to schedule the y longest jobs with resource requirement exactly s , thatis, we have τ s ( y ) = (cid:80) yi =1 p si . Clearly, τ s ( x ) is a concave function that can be precomputed foreach s ∈ [ a max ]. To compute the endpoints, we add:12 w ∈ [ q ] : d w = (cid:88) s ∈ [ a max ] τ s ( x Σ w,s ) . (1)Since we assume gapless schedules, we ensure that there is no gap: ∀ ≤ w ≤ q − d w ≥ u w +1 − . This completes the construction of the mixed ILP using concave transformations. Thenumber of integer variables used in the ILP is 2 q · a max (for x (Σ) w,s variables) plus 2 q ( q for α w and d w variables, respectively). Moreover, the only concave transformations used in ConstraintSet (1) are piecewise linear with only a polynomial number of pieces (in fact, the number ofpieces is at most the number of jobs), as required to obtain fixed-parameter tractability of thisextended class of ILPs [8].Motivated by Theorem 5, we are interested in the computational complexity of the MaterialConsumption Scheduling Problem for cases where only a max is small. When a max = 1, thenwe have polynomial-time solvability via Theorem 3. The next theorem shows that this extendsto every constant value of a max . To obtain this results, we develop a dynamic-progamming-basedalgorithm for 1 , NI | nr = 1 |− and apply Lemma 1. Theorem 6. | nr = 1 | C max can be solved in O ( q · a max · u max · log u max · n a max ) time.Proof. We will describe a dynamic-programming procedure that computes whether there existsa gapless schedule (Lemma 1). We next sort all of the jobs by their respective resource require-ments using bucket sort in O ( n + a max ) time and then sort each of the buckets with respectto the processing times in O ( n log n ) time using merge sort. For the sake of simplicity, we willuse P a [ k ] to describe the set of indices of the k jobs of resource requirement a and longest pro-cessing times. We next define the (cid:96) th phase as the time interval from the start of any possibleschedule up to u (cid:96) +1 . Next, we define a dynamic program T : [ q − × [ n ] ∪ { } × . . . × [ n a max ] ∪ { } → { true, f alse } , where n i is the number of jobs of resource requirement i . We store true in T [ i, x , . . . , x a max ]if and only if it is possible to schedule at least the jobs in P a k [ x k ] such that all of these jobsstart within the i th phase and there is no gap. If T [ q, n , . . . , n a max ] is true, then this cor-responds to a gapless schedule of all jobs and hence this is a solution. We will fill up thetable T by increasing values of the first argument. That is, we will first compute all en-tries T [1 , x , x , . . . , x a max ] for all possible combinations of values for x i ∈ [ n a i ]. For the firstphase, observe that T [1 , x , x , . . . , x a max ] is set to true if and only if the two following con-ditions are met. First, (cid:80) i ∈ [ a max ] x k · a k ≤ b as otherwise there are not enough resourcesavailable in the first i phases. Second, the sum of all processing times of all “selected jobs”without the longest one end at least one time steps before u (as the job with the longest pro-cessing time can then be started at last in time step u − (cid:80) k ∈ [ a max ] (cid:80) j ∈ P ak [ x k ] p j ) − max k ∈ [ a max ] { p j | j ∈ P a k [1] } ≤ u −
1. For increasing values of the first argument, we do the following to com-pute T [ i, x , x , . . . x a max ]. We compute for all tuples of numbers ( y , y , . . . y a max ) with y k ≤ x k for all k ∈ [ a max ] whether T [ i − , y , y , . . . , y a max ] is true and whether this schedule can be ex-tended to a schedule for T [ i, x , x , . . . , x a max ]. This check needs to verify that there are enoughresources for all selected jobs in the i th phase and that there are no gaps in the schedule. Thefirst check is very simple as we only need to check whether (cid:80) k ∈ [ a max ] x k · a k ≤ b i . To check that13his schedule is gapless it is actually enough to check that (cid:80) k ∈ [ a max ] (cid:80) j ∈ P ak [ y k ] p j ≥ u i − i − th phase and since we iterate over all possible combinations of values of y i , we willfind this schedule in another iteration.It remains to analyze the running time of this algorithm. First, the number of table entriesis ( q − · (cid:81) k ∈ [ a max ] ( n k +1) ∈ O ( q · n a max ). Second, for each table entry T [ i, x , x , . . . , x a max ], thereare at most (cid:81) k ∈ [ a max ] ( x k + 1) ≤ (cid:81) k ∈ [ a max ] ( n k + 1) ∈ O ( n a max ) possible tuples ( y , y , . . . , y a max )with y k ≤ x k for all k ∈ [ a max ] and the two checks can be performed in O ( a max ) time. Thus, theoverall running time is O ( q · a max · log u max · n a max ).The question whether 1 | nr = 1 | C max is in FPT or W[1]-hard with respect to a max remainsopen. So far we focused on scenarios with only one non-renewable resource. In this section, we givea brief outlook on scenarios with multiple resources (still considering only one machine). Natu-rally, all hardness results transfer. For the tractability results, we identify several cases wheretractability extends in some form, while other cases become significantly harder.We start with showing that already with two resources and unit processing times of the jobs,the
Material Consumption Scheduling Problem becomes computationally intractable,even when parameterized by the number of supply dates. Note that NP -hardness for 1 | nr =2 , p j = 1 | C max can also be transferred from Grigoriev et al. [21][Theorem 4] (the statement isfor a different optimization goal but the proof works). Proposition 1. | nr = 2 , p j = 1 | C max is W[1] -hard when parameterized by the number of supplydates even if all numbers are encoded in unary.Proof.
Given an instance I of Unary Bin Packing with k bins, each of size B and n ob-jects o , o , . . . o n of size s , s , . . . s n such that (cid:80) ni =1 s i = kB , we construct an instance I (cid:48) of 1 | nr = 2 , p j = 1 | C max as follows.For each i ∈ [ k ] we add a supply q i = ( u i , ˜ b ,i , ˜ b ,i ) := (( i − B, B, B ( B − k supply dates. For each object o i for i ∈ [ n ], we create an object job j i = ( p i , a ,i , a ,i ) :=(1 , s i , B − s i ). Additionally, we create kB − n dummy jobs ; each of them having processingtime 1, no requirement of the resources of the first type, and requiring B resources of the secondtype. We refer to the constructed instance as I (cid:48) .We show that I is a yes-instance if and only if there is a schedule for the constructedinstance I (cid:48) with makespan exactly kB . Clearly, if I is a yes-instance, then there is a k -partitionof the objects to subsets S , S , . . . , S k such that, for each i ∈ k , (cid:80) o j ∈ S i s j = B . For some set S i ,we schedule all jobs in S i , one after another, starting at time ( i − B . Then, in the second step,we schedule the remaining dummy jobs (if they exist) such that we obtain a gapless schedule σ .Naturally, since each S i contains at most B objects, the object jobs are non-overlapping in σ .Since in the second step we have exactly kB − n jobs available (recall that n is the numberof object jobs) σ is a gapless schedule with makespan exactly kB . To check the feasibilityof σ , let us consider the first B time steps. Note that from time 0 to time | S | , the machineprocesses all object jobs representing objects from S ; from time | S | +1 to B it processes exactly B − | S | dummy jobs. Thus, the number of used resources of type 1 is (cid:80) o j ∈ S i s j = B , and the14umber of used resources of type 2 is (cid:80) o j ∈ S i ( B − s j ) + ( B − | S | ) B = | S | B − B + B − | S | B = B ( B − B − B time steps to all following k − B time steps; we eventuallyobtain that σ is a feasible schedule.For the opposite direction, let σ be a schedule with makespan kB for instance I (cid:48) . We againconsider the first B time steps and a set J ph of exactly B jobs processed in this time. Let A and A be the usage of the resource of, respectively, type 1 and type 2 by the jobs in J ph . Wedenote by J o ⊆ J ph the object jobs within J ph . Then, A := (cid:80) j ∈ J o a ,j + (cid:80) j ∈ J ph \ J o a ,j . Infact, since each dummy job has no requirement of the resources of the first type, we have A = (cid:80) j ∈ J o a ,j . Moreover, there are only B resources of type 1 available in the first B time steps,so it is clear that A ≤ B . Using the fact that, for each job j i , it holds that a ,i = B − a ,i , weobtain the following: A := (cid:88) j ∈ J o a ,j + (cid:88) j ∈ J ph \ J o a ,j = | J o | B − A + | J ph \ J o | B = B − A . Using the above relation between A and A , we show that A = B . For the sake ofcontradiction, assume A < B . Immediately, we obtain that A > B − B = B ( B − B ( B −
1) resources of the second type in the first B timesteps of schedule σ . Thus, since A = B , we use exactly B resources of the first type andexactly ( B − B resources of the second type in the first B time steps of σ . We can repeat thewhole argument to all following k − B time steps. Eventually, we obtain a solutionto I by taking the objects corresponding to the object jobs scheduled in the subsequent periodsof B -time steps.The reduction is clearly applicable in polynomial time and the number of supply dates is afunction of solely the number of bins in an instance of Unary Bin Packing .Proposition 1 limits the hope for obtaining positive results for the general case with multipleresources. Still, when adding the number of different resources to the combined parameter, wecan extend our fixed-parameter tractability result from Theorem 5. Since we expect the numberof different resources to be rather small in real-world applications, we consider this result to beof practical interest.
Proposition 2. , NI | nr = r | C max is fixed-parameter tractable for the combined parameter q + a max + r , where q is the number of supplies and a max is the maximum resource requirementof a job.Proof Sketch. The main observation needed to extend the ILP from Theorem 5 is that, byLemma 2, given two jobs with the same resource requirement, there is always a schedule thatfirst schedules the longer (dominating) jobs. In essence, for each phase and each possible re-source requirement, a solution is still fully described by the respective number of jobs withthat requirement scheduled in the phase (it is clear that among jobs with the same resourcerequirement we can schedule jobs with decreasing length).For multiple resources, we describe the resource requirement of job j by a resource vector (cid:126)s =( a ,j , a ,j , . . . , a r,j ). We use the following non-negative integer variables:1. x w,(cid:126)s denoting the number of jobs with resource vector (cid:126)s being started in phase w ,15. x Σ w,(cid:126)s denoting the number of jobs with resource vector (cid:126)s being started between phase 1 to w ,3. α y,w denoting the number of resources of type y available in the beginning of phase w ,4. d w denoting the endpoint of phase w , that is, the time when the job started latest inphase w ends.All constraints and proof arguments translate in a straightforward way.Finally, by a reduction from Independent Set we show that the
Material Consump-tion Scheduling Problem is intractable for an unbounded number of resources even whencombining all considered parameters.
Theorem 7. | nr , p j = 1 | C max is NP -hard and W[1] -hard parameterized by u max even if p max = a max = b max = 1 and q = 2 .Proof. We provide a parameterized reduction from the
Independet Set problem which, givenan undirected graph G and a positive integer k , asks whether there is an independet set of size k ,that is, a set of k vertices in G which are pairwise non-adjacent. Independent Set is W[1]-hardfor the size k of the independet set.Given an Independent Set instance (
G, k ) we create an instance of 1 | nr , p j = 1 | C max asfollows. Let V ( G ) = { v , . . . , v n } and E ( G ) = { e , . . . , e m } . For each edge in G , we create oneresource, that is, nr = m . At time u = 0, we provide one initial unit of every resource. Attime u = k , we provide another unit of every resource. For each vertex v j ∈ V ( G ), there is onejob J j of length one with resource requirement being consistent with the incident edges, that is, a i,j = 1 if v j ∈ e i and a i,j = 0 if v j / ∈ e i .We claim that there is a schedule with makespan C max = n if and only if there is anindependent set of size k .For the “if” direction, let V (cid:48) = { v (cid:96) , . . . , v (cid:96) k } be an independent set in G . Observe that everyschedule that schedules the jobs J (cid:96) , . . . , J (cid:96) k (in any order) in the first phase and then all otherjobs (in any order) in the second phase is feasible and has makespan C max = n . Feasibility comesfrom the fact that we have an independent set so that no two jobs scheduled in the first phaserequire the same resource. (After the second supply, there are enough resources to schedule alljobs.) The makespan can be verified by observing that we have unit processing time and thatthe machine does not idle.For the “only if” direction, assume that there is a feasible schedule with makespan C max = n and let J (cid:48) = { J j , . . . , J j k } be the jobs which are scheduled at timepoints 0 to k −
1. (Note that J (cid:48) is well-defined since each job has length one, there are n jobs in total, and the makespan is n .)We claim that the set V (cid:48) = { v j , . . . , v j k } is an independent set. Assume towards a contradictionthat two vertices are adjacent. Then, both jobs are scheduled in the first phase and require oneunit of the the same edge resource; a contradiction. We provided a seemingly first thorough multivariate complexity analysis of the
Material Con-sumption Scheduling Problem on a single machine. Our main concern was the case of oneresource type (nr = 1). 16pen questions here refer to the parameterized complexity with respect to the single pa-rameters a max and p max , their combination, and the closely related parameter number of jobtypes. Notably, this might be challenging to answer because these questions are closely relatedto long-standing open questions for Bin Packing and P || C max [40, 37, 38]. Indeed, parametercombinations may be unavoidable to identify practically relevant tractable cases. Note thatit is not hard to derive from our statements (particularly Assumption 1 and Lemma 1) fixed-parameter tractability for b max + q while for the single parameters b max and q it is both timescomputationally hard.Another challenge is to study the case of multiple machines, which is obviously computa-tionally at least as hard as the case of a single machine but possibly very relevant in practice.It is, however, far from obvious to generalize our algorithms to the multiple-machines case.We have also seen that cases where the jobs can be ordered with respect to the dominationordering (Definition 1) are polynomial-time solvable. It seems promising to consider structuralparameters measuring the distance from this tractable case in the spirit of distance from trivialityparameterization [22, 42].Our results for multiple resources certainly mean only first steps. They invite to furtherinvestigations. Acknowledgments
Main work done while RB was with TU Berlin. AK was supported by the DFG project AFFA(BR 5207/1 and NI 369/15). PG was supported by the National Research, Development andInnovation Office – NKFIH (ED 18-2-2018-0006), and by the J. Bolyai Research Scholarship.Project started while RB, PG, and RN were attending the Lorentz center workshop “SchedulingMeets Fixed-Parameter Tractability” February 4–8, 2019, Leiden, the Netherlands, organizedby Nicole Megow, Matthias Mnich, and Gerhard J. Woeginger.
References [1] F. Belkaid, F. Maliki, F. Boudahri, and Z. Sari. A branch and bound algorithm to mini-mize makespan on identical parallel machines with consumable resources. In
Advances inMechanical and Electronic Engineering , pages 217–221. Springer, 2012.[2] M. Bentert, R. van Bevern, and R. Niedermeier. Inductive k -independent graphs and c -colorable subgraphs in scheduling: a review. Journal of Scheduling , 22(1):3–20, 2019.[3] K. B´erczi, T. Kir´aly, and S. Omlor. Scheduling with non-renewable resources: Minimiz-ing the sum of completion times. In
Proceedings of the 6th International Symposium onCombinatorial Optimization , pages 167–178. Springer, 2020.[4] R. van Bevern, M. Mnich, R. Niedermeier, and M. Weller. Interval scheduling and colorfulindependent sets.
Journal of Scheduling , 18(5):449–469, 2015.[5] R. van Bevern, R. Niedermeier, and O. Such´y. A parameterized complexity view on non-preemptively scheduling interval-constrained jobs: few machines, small looseness, and smallslack.
Journal of Scheduling , 20(3):255–265, 2017.176] H. L. Bodlaender and M. R. Fellows. W[2]-hardness of precedence constrained k -processorscheduling. Operations Research Letters , 18(2):93–97, 1995.[7] H. L. Bodlaender and M. van der Wegen. Parameterized complexity of scheduling chainsof jobs with delays. In
Proceedings of the 15th International Symposium on Parameterizedand Exact Computation (IPEC ’20) , pages 4:1–4:15. Schloss Dagstuhl - Leibniz-Zentrumf¨ur Informatik, 2020.[8] R. Bredereck, P. Faliszewski, R. Niedermeier, P. Skowron, and N. Talmon. Mixed integerprogramming with convex/concave constraints: Fixed-parameter tractability and applica-tions to multicovering and voting.
Theoretical Computer Science , 814:86–105, 2020.[9] J. Carlier.
Probl`emes d’ordonnancements `a contraintes de ressources: algorithmes et com-plexit´e. Th`ese d’´etat . Universit´e Paris 6, 1984.[10] J. Carlier and A. H. G. Rinnooy Kan. Scheduling subject to nonrenewable resource con-straints.
Operations Research Letters , 1:52–55, 1982.[11] S. Carrera, W. Ramdane-Cherif, and M.-C. Portmann. Scheduling supply chain node withfixed component arrivals and two partially flexible deliveries. In
Proceedings of the 5thInternational Conference on Management and Control of Production and Logistics (MCPL’10) , page 6. IFAC Publisher, 2010.[12] P. Chr´etienne. On single-machine scheduling without intermediate delays.
Discrete AppliedMathematics , 156(13):2543–2550, 2008.[13] M. Cygan, F. V. Fomin, L. Kowalik, D. Lokshtanov, D. Marx, M. Pilipczuk, M. Pilipczuk,and S. Saurabh.
Parameterized Algorithms . Springer, 2015.[14] M. Davari, M. Ranjbar, P. De Causmaecker, and R. Leus. Minimizing makespan on a singlemachine with release dates and inventory constraints.
European Journal of OperationalResearch , 286(1):115–128, 2020.[15] R. G. Downey and M. R. Fellows.
Fundamentals of Parameterized Complexity . Springer,2013.[16] M. R. Fellows and C. McCartin. On the parametric complexity of schedules to minimizetardy tasks.
Theoretical Computer Science , 298(2):317–324, 2003.[17] J. Flum and M. Grohe.
Parameterized Complexity Theory . Springer, 2006.[18] A. Frank and ´E. Tardos. An application of simultaneous Diophantine approximation incombinatorial optimization.
Combinatorica , 7(1):49–65, 1987.[19] R. Ganian, T. Hamm, and G. Mescoff. The complexity landscape of resource-constrainedscheduling. In
Proceedings of the 29th International Joint Conference on Artificial Intelli-gence (IJCAI ’20) , pages 1741–1747. ijcai.org, 2020.[20] R. L. Graham, E. L. Lawler, J. K. Lenstra, and A. R. Kan. Optimization and approximationin deterministic sequencing and scheduling: a survey.
Annals of Discrete Mathematics , 5:287–326, 1979. 1821] A. Grigoriev, M. Holthuijsen, and J. van de Klundert. Basic scheduling problems with rawmaterial constraints.
Naval Research of Logistics , 52:527–553, 2005.[22] J. Guo, F. H¨uffner, and R. Niedermeier. A structural view on parameterizing problems: Dis-tance from triviality. In
Proceedings of the First International Workshop on Parameterizedand Exact Computation , pages 162–173. Springer, 2004.[23] P. Gy¨orgyi and T. Kis. Approximation schemes for single machine scheduling with non-renewable resource constraints.
Journal of Scheduling , 17:135–144, 2014.[24] P. Gy¨orgyi and T. Kis. Reductions between scheduling problems with non-renewable re-sources and knapsack problems.
Theoretical Computer Science , 565:63–76, 2015.[25] P. Gy¨orgyi and T. Kis. Approximability of scheduling problems with resource consumingjobs.
Annals of Operations Research , 235(1):319–336, 2015.[26] P. Gy¨orgyi and T. Kis. Approximation schemes for parallel machine scheduling with non-renewable resources.
European Journal of Operational Research , 258(1):113–123, 2017.[27] P. Gy¨orgyi and T. Kis. Minimizing total weighted completion time on a single machinesubject to non-renewable resource constraints.
Journal of Scheduling , 22(6):623–634, 2019.[28] P. Gy¨orgyi and T. Kis. New complexity and approximability results for minimizing thetotal weighted completion time on a single machine subject to non-renewable resourceconstraints. arXiv preprint arXiv:2004.00972 , 2020.[29] K. Heeger, D. Hermelin, G. B. Mertzios, H. Molter, R. Niedermeier, and D. Shabtay.Equitable scheduling on a single machine. In
Proceedings of the 35th AAAI Conference onArtificial Intelligence (AAAI ’21) . AAAI Press, 2021.[30] D. Hermelin, J.-M. Kubitza, D. Shabtay, N. Talmon, and G. J. Woeginger. Scheduling twoagents on a single machine: A parameterized analysis of np-hard problems.
Omega , 83:275–286, 2019.[31] D. Hermelin, M. Pinedo, D. Shabtay, and N. Talmon. On the parameterized tractability ofsingle machine scheduling with rejection.
European Journal of Operational Research , 273(1):67–73, 2019.[32] D. Hermelin, D. Shabtay, and N. Talmon. On the parameterized tractability of the just-in-time flow-shop scheduling problem.
Journal of Scheduling , 22(6):663–676, 2019.[33] D. Hermelin, G. Manoussakis, M. Pinedo, D. Shabtay, and L. Yedidsion. Parameterizedmulti-scenario single-machine scheduling problems.
Algorithmica , 82(9):2644–2667, 2020.[34] O. Herr and A. Goel. Minimising total tardiness for a single machine scheduling problemwith family setups and resource constraints.
European Journal of Operational Research ,248(1):123–135, 2016.[35] K. Jansen, S. Kratsch, D. Marx, and I. Schlotter. Bin packing with fixed number of binsrevisited.
Journal of Computer and System Sciences , 79(1):39–49, 2013.1936] R. Kannan. Minkowski’s convex body theorem and integer programming.
Mathematics ofOperations Research , 12(3):415–440, 1987.[37] D. Knop and M. Kouteck´y. Scheduling meets n -fold integer programming. Journal ofScheduling , 21(5):493–503, 2018.[38] D. Knop, M. Kouteck´y, and M. Mnich. Combinatorial n -fold integer programming andapplications. Mathematical Programming , 184(1):1–34, 2020.[39] H. W. Lenstra, Jr. Integer programming with a fixed number of variables.
Mathematics ofOperations Research , 8(4):538–548, 1983.[40] M. Mnich and R. van Bevern. Parameterized complexity of machine scheduling: 15 openproblems.
Computers & Operations Research , 100:254–261, 2018.[41] M. Mnich and A. Wiese. Scheduling and fixed-parameter tractability.
Mathematical Pro-gramming , 154(1-2):533–562, 2015.[42] R. Niedermeier.
Invitation to Fixed-Parameter Algorithms . Oxford University Press, 2006.[43] R. Slowinski. Preemptive scheduling of independent jobs on parallel machines subject tofinancial constraints.
European Journal of Operational Research , 15:366–373, 1984.[44] A. Toker, S. Kondakci, and N. Erkip. Scheduling under a non-renewable resource constraint.
Journal of the Operational Research Society , 42:811–814, 1991.[45] J. Xie. Polynomial algorithms for single machine scheduling problems with financial con-straints.