On Scheduling Unit-Length Jobs with Multiple Release Time/Deadline Intervals

On Scheduling Unit-Length Jobs with Multiple Release Time/Deadline IntervalsAuthor(s): Barbara Simons and Michael SipserSource: Operations Research, Vol. 32, No. 1 (Jan. - Feb., 1984), pp. 80-88Published by: INFORMSStable URL: http://www.jstor.org/stable/170522 .

Accessed: 08/05/2014 11:00

Your use of the JSTOR archive indicates your acceptance of the Terms & Conditions of Use, available at .http://www.jstor.org/page/info/about/policies/terms.jsp

.JSTOR is a not-for-profit service that helps scholars, researchers, and students discover, use, and build upon a wide range ofcontent in a trusted digital archive. We use information technology and tools to increase productivity and facilitate new formsof scholarship. For more information about JSTOR, please contact [email protected].

.

INFORMS is collaborating with JSTOR to digitize, preserve and extend access to Operations Research.

http://www.jstor.org

This content downloaded from 169.229.32.137 on Thu, 8 May 2014 11:00:40 AMAll use subject to JSTOR Terms and Conditions

http://www.jstor.org/action/showPublisher?publisherCode=informs

http://www.jstor.org/stable/170522?origin=JSTOR-pdf

http://www.jstor.org/page/info/about/policies/terms.jsp


On Scheduling Unit-Length Jobs with Multiple Release Time/Deadline Intervals

BARBARA SIMONS IBM Research, San Jose, California

MICHAEL SIPSER Massachusetts Institute of Technology, Cambridge, Massachusetts

(Received December 1981; accepted December 1982)

We consider the problem of scheduling n unit-time jobs with multiple release time/deadline intervals, which are intervals of time in which the job can be scheduled. A feasible schedule is one in which each job is run in its entirety within one of its release time/deadline intervals. We show that the general problem is NP-complete, but that for a special case one can determine in polynomial time if a feasible schedule exists. If there is a feasible schedule for the special case, then it is possible to obtain both a schedule that minimizes the maximum completion time and also one that minimizes the sum of the completion times of all jobs. If, on the other hand, there is no feasible schedule, then one can determine the minimum number of jobs that must be removed to make the problem instance feasible.

THE SCHEDULING problem being considering is a generalization of the following problem. We are given a set of n unit-time jobs,

J(1), J(2), * , J(n). Each job J(i) has a release time r(i) and a deadline d(i). The release time of a job is the earliest time at which processing can begin on it and the deadline is the time by which processing must be completed. We assume that once processing has begun on a job, it must run for one unit of time without interruption. We shall refer to a release time/deadline interval with endpoints r(i) and d (i) as an rld interval.

If we allow the jobs to have different processing times, the problem becomes strongly NP-complete (Karp [1972], Garey. and Johnson [1978]) even if all jobs must be run on only one machine (Lenstra et al. [1977]). Garey and Johnson [1978] have shown that it remains NP- complete even if only two different release times and two different deadlines are allowed.

If, however, all the jobs have unit processing times, integer release times and deadlines, and no partial order, then the problem has a

Subject classification: 432 polynomial time algorithm and NP completeness, 486 scheduling with release times, 584 scheduling unit-time jobs on identical machines.

Operations Research Vol. 32, No. 1, January-February 1984

0030-364X/84/3201-0080 $01.25 ? 1984 Operations Research Society of America

80



Scheduling Unit-Length Jobs 81

polynomial time algorithm. An O(n log n) algorithm, called the Earliest Deadline Algorithm, has been known for some time to work in the multimachine case (Jackson [1955]). Furthermore, there are polynomial time algorithms for the single-machine case with arbitrary release times, deadlines, and partial orders (Simons [1978] and Garey et al. [1981]). The fastest of these algorithms, presented in Garey et al., runs in O(n log n) time.

By contrast, Ullman [1975] has shown that the problem with unit- processing times, an arbitrary partial order, and a variable number of machines is NP-complete, even with all release times equal to 0 and only one deadline. Nonetheless, the two-machine version with integer release times, arbitrary deadlines, unit running time, and a partial order has a polynomial time algorithm (Garey and Johnson [19771). Also, the multimachine problem with unconstrained release times, deadlines, unit- processing time, and no partial order has a polynomial time algorithm (Simons [1980, 1981]).

Since slight perturbations of the general problem seem to send it across the boundary between P and NP-complete, it is of interest to know just how far one can push the version which is polynomial while having it remain polynomial. If we do not have precedence constraints, all jobs have unit running time, and a job can have more than one release time/ deadline (rid) interval in which it can run, does the problem remain in P?

An example of a multiple r/d interval problem is the kidney machine problem. For this problem we have a set of kidney dialysis machines and a set of patients who must use the machines each week. Each patient has a set of rid intervals corresponding to the times at which s/he can come in to use the machine. The problem is to determine if one can schedule all the patients without violating any of the constraints. As we show below, this problem is NP-complete even if there is only one machine. If, however, we normalize the time required on a machine to one unit of time, and if each patient has an arbitrary number of r/d intervals with integer endpoints, then the problem has a polynomial time algorithm.

1. AN NP-COMPLETENESS REDUCTION

To prove that the single kidney machine problem is NP-complete, we show that it is at least as hard as the 3-Satisfiability problem (3-Sat), which was shown by Cook [19711 to be NP-complete. To prove that a problem is no harder than an NP-complete problem, one need demon- strate only that the correctness of a proposed solution can be verified in polynomial time. We leave this aspect of the correctness proof to the reader.



82 Simons and Sipser

The 3-Sat problem consists of a set of Boolean variables and a set of clauses. If v is a variable, then both v and -v are literals. A truth assignment is a function that assigns to each variable either the value "true" or the value "false." A clause is the disjunct of three literals, that is, a clause is true if and only if at least one of the literals evaluates to true. A problem instance is the conjunction of a set of clauses, that is, an instance evaluates to "true" if and only if each of the clauses evaluates to true. The 3-Sat problem consists of determining if there is a truth assignment such that the problem instance evaluates to "true." For a thorough discussion of the satisfiability problem and NP-completeness reductions, see Garey and Johnson [1978].

The version of the single kidney machine problem that we shall use for the reduction is one in which all the release times and deadlines are integers and each job requires two units of processing. Note that this problem is equivalent to one in which each job requires one unit of processing and release times and deadlines are integral multiples of 1/2.

Assume we have an instance of 3-Sat with n variables and m clauses, where a1, a2, . . ., an are the variables and c1, c2, ... I cm are the clauses. Let Ai = the total number of occurrences of as or its complement in all of the clauses. For each variable as we shall create 2Ai + 1 "variable- jobs," a(i, 0), a(i, 1), * * *, a(i, 2A), each with two rid intervals. For each clause ci we shall create one "clause-job," c(i), which can be run in any of three rld intervals.

Each variable will have a "double ladder" of rid intervals for its variable-jobs. Figure 1 illustrates such a variable double ladder together with the placement of some clause job rld intervals. Let us first consider variable a1 and its associated variable-jobs a(l, j), 0 ' j c 2A1. The earliest rid interval for a(l, j) is (j, j + 2). Let T1 = 2A1 + 2, the endpoint of the first interval for a(l, 2A1). Then the second rld interval is (T1 + 2j, T1 + 2j + 2) for all odd j and (T1 + 2j - 1, T1 + 2j + 1) for all even j.

Without loss of generality, we can assume that the clauses in which a1 or its complement occurs are cl, c2, * * *, Ck, where k = A1. The occurrence of a1 in these clauses produces one of the three rid intervals for the clause jobs c(l), c(2), * * *, c(k) of the scheduling instance. If a, occurs in its unnegated form in c1, then we create an rid interval for c(l) of (T1 + 1, T1 + 3). Otherwise, a1 occurs in c1 in its negated form and we assign c(l) an interval of (T1, T1 + 2).

Similarly, we create for c(2) an rid interval of (T1 + 5, T1 + 7) if a1 occurs in c2 in its unnegated form and (T1 + 4, TI + 6) otherwise. In general, if a1 occurs in ci and if the second rld interval for a(l, 2i - 1) is (a, a + 2), then we create an rid interval for ci of (a - 1, a + 1) or (a -

2, a) according as a, occurs in its unnegated or negated form. The generalization of the construction to the remaining variables is

straightforward. Create a similar "double ladder" for a2 by having the




first interval of a(2, 1) begin one unit past the right endpoint of the latest interval for a,, and then continue with the same construction as described above. An occurrence of a2 or its complement in clause ci creates an rld interval for c(i). The process is repeated for a3, and so on.

We shall say that a variable ai is encoded to the value "true" if jobs a(i, j) for all even j are run in their second interval and "false" if jobs a(1, j) for all even j are run in their first interval. The encoding of variable ai is consistent if and only if ai has been assigned either the value "true" or the value "false" as defined above. Otherwise, we will say that the consistency of the encoding of variable ai has been violated.

Clause Jobs

c(4) c(3)'

c(1)

Var Jobs

a(1, 8) atl, 7) a(l, 6) a(l, 5) af1, 4) a(l, 3) a(l, 2) a(l, 1) a(l, 0)

0 5 10 15 20 25 30

t T1

(a, Va2Va3)A(a1 Va3Va4)A(a1 Va2\Va3)A(al Va4Vi5)A ...

cl C2 C3 C4

A1 4 T1 = 10

Figure 1. An example of the NP-completeness construction.

LEMMA 1. If for variable as all jobs a(i, j) are scheduled, then the consistency of the encoding of ai is not violated.

Proof. Without loss of generality and to simplify the notation, we shall assume that i = 1.

Suppose that a(1, 0) is run in its first interval. Then a(1, 1) must be run in its second interval because its first interval overlaps with the first interval of a(1, 0). Now a(1, 2) must be run in its first interval because its second interval overlaps with that of a(1, 1), and so on. So by running a(l, 0) in its first interval we have forced the intervals for all a(l, j) if




they are all to be run. We note that this is equivalent to an encoding of the value "false" for a,.

Suppose instead that we schedule a(1, 0) to run in its second interval. Since the second interval of a(1, 1) does not overlap with the second interval of a(1, 0), a(1, 1) can be run in either of its intervals. So suppose that a(1, 1) is scheduled in its second interval (thereby violating the consistency of the encoding of variable a,). Then by the above argument, the intervals for the remaining a(1, j) are forced. But now there is no way in which a(1, 2A1) can be scheduled, for its first interval overlaps with the second interval of a(1, 0) and its second interval overlaps with the second interval of a(i, 2A1 - 1). The same argument would apply if for any odd j, a(1, j) were to be scheduled in its second interval. If, on the other hand, for all odd j, a(1, j) is scheduled in its first interval, then for all even j, a(1, j) can be scheduled in its second interval, which is equivalent to an encoding of the value true.

LEMMA 2. Suppose that a, occurs in clause cq and that all jobs a(i, j) for O c j c 2Ai are scheduled. Then clause job c(q) can be run in the interval corresponding to the occurrence of ai in cq if and only if either ai occurs in its unnegated form in cq and ai has been encoded to the value "true" or aL occurs in its negated form and ai has been encoded to the value "false."

Proof. To simplify the notation, we shall assume i = q = 1. If a, has been assigned the value "true," then both a(1, 0) and a(1, 2) will be run in their second intervals, which are respectively (T1 - 1, T1 + 1) and (T1 + 3, T1 + 5). Since a(1, 1) is run in its first interval, it is still possible to run c(1) in its first interval of (T1 + 1, T1 + 3), which is the interval assigned to c(1) if a1 occurs in its unnegated form in c(1). Similarly, if a1 has been assigned the value "false," then a(1, 1) will run in its second interval of (T1 + 2, T1 + 4), and both a(1, 0) and a(1, 2) will run in their first intervals. Once again, c(1) can run in its "negative" interval of (T1, T1 + 2).

Conversely, if a, has been assigned the value "true" and a1 occurs in its negated form in cl, then the "negative" interval of (T1, T1 + 2) cannot be used to run c(1) since a(1, 0) is run in (T1 - 1, T, + 1). Similarly, if a, has been assigned the value "false" but occurs in it unnegated form in cl, then c(1) cannot run in its "positive" interval of (T1 + 1, T1 + 3) since a(1, 1) will be run in (T1 + 2, T1 + 4).

THEOREM 1. The multiple rid interval problem is NP-complete.

Proof. By Lemmas 1 and 2 all jobs a(i, j) and c(q) will be run if and only if the corresponding instance of 3-SAT has an assignment of values to the variables such that the formula evaluates to true.

The following modification, suggested by Manfred Warmuth, elim- inates the need for three rld intervals. Instead of creatina one clause-




job, c(i), for clause ci, we create three clause-jobs, c(i, 1), c(i, 2), and c(i, 3). The first interval for c(i, j) corresponds to the jth interval of c(i) for 1 c j c 3. The second interval for c(i, j) for 1 c j c 3 will be a "garbage interval" of length four. Let U = the (right) endpoint of the last variable- job r/d interval. Then the "garbage interval" for c(i, j) will be (U + 4(i - 1), U + 4i). Note that at most two of the three c(i, j) intervaljobs corresponding to ci can be scheduled within the "garbage interval." This fact forces an assignment of "true" for at least one of the literals in clause ci if all of the clause-variables corresponding to ci are to be scheduled. Consequently, the problem is NP-complete even if we allow only two r/d intervals per job.

2. A POLYNOMIAL TIME VERSION

We now consider the problem in which all jobs have unit running time and an arbitrary number of disjoint rld intervals with integer left and right endpoints. The question of whether or not a problem instance has a feasible schedule can be solved in polynomial time, even if there is a variable number, m, of identical machines on which to schedule the jobs. Intuitively, this subproblem has a fast algorithm because if there is a feasible schedule, then there is one in which all jobs start at integral times. Consequently, problem of overlapping can be eliminated.

The polynomial time algorithm is obtained by transforming the scheduling problem into a matching problem on a bipartite graph (Hopcroft and Karp [1973]). One aspect of the transformation involves partitioning the r/d intervals into unit-length intervals. To bound the time and space complexity of the transformation, we need a limit on the number of unit- length intervals so obtained. In particular, it is necessary to show that the problem size increases by at most a polynomial factor in the size of the original scheduling problem. Lemma 3 shows that for any job the sum of the lengths of its rld intervals need never exceed rn/ml, where rn/ml is the smallest integer which is greater than or equal to n/m.

LEMMA 3. Suppose some job J(i) has r/d intervals whose lengths sum to at least rn/ml, where m is the number of machines in the problem instance. Suppose also that the kth interval is partitioned into at most two subintervals so that the length of the first subinterval when added to the length of the previous k - 1 intervals sums to rn/mi. Then the elimination of the latter subinterval and all remaining intervals for J(i) will not affect feasibility.

Proof. We note that because all rld intervals have integral endpoints, if the kth interval is partitioned into two subintervals, the point of partition must be integer to satisfy the constraint that the lengths of the first k - 1 intervals together with the length of the subinterval sum to precisely fn/ml.




Consider the subproblem consisting of all jobs but J(i). If there is no feasible schedule for this problem, then clearly there is none for the problem instance including J(i). If there is a feasible schedule for the subproblem, then there is one in which all the jobs are started at integer times. Since multiplying the number of machines by the time intervals in which J(i) can be run gives rn/mlm > n, there must be at least one subinterval of length one within the rid intervals of J(i) during which no job is scheduled on at least one of the machines. So J(i) can always be scheduled within some rid interval.

By Lemma 3 we can assume that the total amount of time for which any job is available is equivalent to no more than rn/ml unit-length intervals. We shall also assume that any intervals of length greater than one have been divided into unit-length intervals. Consequently, there will be no more than n2/m + n distinct unit length intervals to consider. Order these intervals by their left endpoints, and call the ordered intervals I(1), I(2), - *, I(N), where N < n2/M + n.

We can transform the scheduling problem into a matching problem by constructing a bipartite graph. Let G = (S, T, E) be the bipartite graph, where S U T is the set of nodes, S n T = X, E is the set of edges, and each edge is adjacent to a node in S and a node in T. The S nodes correspond to the jobs and are labeled J1, J2, ... , Jn. The T nodes consist of m representatives for each interval. We shall refer to these nodes as I1,1, I1,2, .. . . I1,m, I2,1 .. . , I2,ms * . IN,m. There is an edge between Ji and Ij,1, Ij,2, ... , Ij,m if and only if the ith job is available in the jth interval.

THEOREM 2. There is a feasible schedule for the m-machine scheduling problem for unit-length jobs with rid intervals having integer endpoints if and only if there is a matching of size n.

Proof. Suppose there is a matching of size n. Then for 1 c i c n, Ji is adjacent to some edge in the matching. To obtain a feasible schedule from a matching of size n, we schedule J(i) in the r/d interval and on the machine represented by the node to which Jt is adjacent in the matching. It is clear from the labeling that no machines capacity will be exceeded. Furthermore, the definition of the edges in the graph guaran- tees that a job is scheduled only during one of its rid intervals.

Conversely, suppose that the scheduling problem has a feasible schedule. Based on previous arguments, we can assume that every job has an integer start time and no more than m jobs are scheduled during any rid interval. Consequently, by reversing the procedure used to obtain a feasible schedule from a matching of size n, we can obtain a matching of size n directly from the feasible schedule.




THEOREM 3. The running time for the m-machine scheduling problem is O(n3).

Proof. Let G = (S, T, E) be a bipartite graph, where I S I + I T I = v and I E I = e. One can compute the maximum cardinality matching for G in W((e + v)v05) time (Hopcroft and Karp). Since each "job" node is adjacent to at most n "interval" nodes, and since there can be 0(n2)

"interval" nodes, both e and v are 0(n2). Hence, the running time for determining if the scheduling problem has a feasible solution is 0(n3).

We now show how to solve several optimization problems using weighted bipartite matching. Let G be a graph with weights on all the edges. Then a maximum weighted matching on G is a matching M such that for all matchings M', the sum of the weights of the edges in M > the sum of the weights of the edges in M'.

COROLLARY 1. If there is a feasible schedule for an instance of the m- machine scheduling problem for multiple rid intervals with integer endpoints, then in 0(n4) time it is possible to obtain a schedule that minimizes the completion time of the last job.

Proof. We use the max-min matching algorithm, which is presented in detail in Lawler [1976]. This algorithm produces a maximum cardinality matching for which the largest edge weight is minimized.

Let (u, v) be an edge in the bipartite graph, let v be the "interval" node, and let (k, k + 1) be the interval to which v corresponds. Then (u, v) is given the weight k. For a weighted bipartite graph G = (S, T, E), where I S I = p, I T I = q, and p : q, the running time of the max-min matching algorithm is 0(p2q). The bipartite graph constructed to solve the scheduling problem has p = n "job" nodes and q = 0(n2) "interval" nodes. Consequently the running time is 0(n4).

COROLLARY 2. For an instance of the m-machine scheduling problem for multiple rid intervals with integer endpoints, one can construct a schedule in 0(n4) time which both maximizes the number of jobs scheduled and minimizes the sum of their completion times.

This result is obtained by constructing the same bipartite graph as that used in Corollary 1 and finding for this graph the maximum cardinality matching of minimum total weight. This type of problem has been discussed in the literature (see Lawler). Since the weight of an edge in the graph is equal to the value of the interval node to which it is adjacent, one can associate the weights with the interval nodes rather than the edges. The matching is constructed by always considering as the next candidate node for addition to the matching the interval node of lowest weight that has not yet been either added to the matching or




rejected. If an augmenting path is discovered from that node, then the matching is augmented. Otherwise, the node is rejected and the interval node with the next highest value becomes the candidate node. The process halts when either a matching of cardinality n is obtained or when all of the interval nodes have been examined. Each attempt at augmenting requires O(E) steps and there are 0(n2) interval nodes, giving a running time of (0(n4).

ACKNOWLEDGMENTS

We would like to thank Charles Martel for having suggested the kidney dialysis problem as a "real life" example and Maria Klawe for having observed that the bipartite graph technique generalizes to the m-machine case.

REFERENCES

COOK, S. A. 1971. The Complexity of Theorem-Proving Procedures. In Proceed- ings of the Third Annual ACM Symposium on Theory of Computing, pp. 151- 158.

GAREY, M. R., AND D. S. JOHNSON. 1977. Two-Processor Scheduling with Start- Times and Deadlines. SIAM J. Comput. 6, 416-426.

GAREY, M. R., AND D. S. JOHNSON. 1978. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman, San Francisco.

GAREY, M. R., D. S. JOHNSON, B. B. SIMONS AND R. E. TARJAN. 1981. Scheduling Unit-Time Tasks with Arbitrary Release Times and Deadlines. SIAM J. Comput. 10, 256-269.

HOPCROFT, J. E., AND R. M. KARP. 1973. An n25 Algorithm for Maximum Matchings in Bipartite Graphs. SIAM J. Comput. 2, 225-231.

JACKSON, J. R. 1955. Scheduling a Production Line to Minimize Maximum Tardiness, Research Report 43, Management Science Research Project, UCLA.

KARP, R. M. 1972. Reducibility among Combinatorial Problems. In Complexity of Computer Computations, pp. 85-103, R. E. Miller and J. M. Thatcher (eds.). Plenum Press, New York.

LAWLER, E. L. 1976. Combinatorial Optimization: Networks and Matroids. Holt, Rinehart & Winston, New York.

LENSTRA, J. K., A. H. G. RINNOOY KAN, AND P. BRUCKER. 1977. Complexity of Machine Scheduling Problems. Ann. Discrete Math. 1, 343-362.

SIMONS, B. B. 1978. A Fast Algorithm for Single Processor Scheduling. In 19th Annual Symposium on Foundations of Computer Science, pp. 246-252. IEEE Computer Society, Long Beach, Calif.

SIMONS, B. B. 1980. A Fast Algorithm for Multiprocessor Scheduling. In 21st Annual Symposium on Foundations of Computer Science, pp. 50-53. IEEE Computer Society, Long Beach, Calif.

SIMONS, B. B. 1981. Multiprocessor Scheduling of Unit-Time Jobs with Arbitrary Release Times and Deadlines, IBM Research Report RJ 3235, San Jose, Calif.

ULLMAN, J. D. 1975. NP-Complete Scheduling Problems. J. Comput. Syst. Sci. 10, 384-393.



Documents

On Scheduling Unit-Length Jobs with Multiple Release Time/Deadline Intervals