ALGO-first_submis

21 Pages·2015·0.4 MB·English

Libraries and Learning Services

University of Auckland Research
Repository, ResearchSpace

Version
This is the Accepted Manuscript version. This version is defined in the NISO
recommended practice RP-8-2008 http://www.niso.org/publications/rp/

Suggested Reference
Gavryushkin, A., Khoussainov, B., Kokho, M., & Liu, J. (2016). Dynamic
Algorithms for Multimachine Interval Scheduling Through Analysis of Idle
Intervals. Algorithmica, 76(4), 1160-1180. doi:10.1007/s00453-016-0148-5

Copyright
Items in ResearchSpace are protected by copyright, with all rights reserved,
unless otherwise indicated. Previously published items are made available in
accordance with the copyright policy of the publisher.
The final publication is available at Springer via
http://dx.doi.org/10.1007/s00453-016-0148-5
For more information, see General copyright, Publisher copyright,
SHERPA/RoMEO.
Algorithmica

Dynamic Algorithms for Multimachine Interval Scheduling
--Manuscript Draft--

Manuscript Number: ALGO-D-15-00018
Full Title: Dynamic Algorithms for Multimachine Interval Scheduling
Article Type: S.I. : ISAAC 2014
Keywords: interval scheduling; fixed job scheduling; idle intervals
Corresponding Author: Mikhail Kokho
The University of Auckland
Auckland, NEW ZEALAND
Corresponding Author Secondary
Information:
Corresponding Author's Institution: The University of Auckland
Corresponding Author's Secondary
Institution:
First Author: Alexander Gavruskin
First Author Secondary Information:
Order of Authors: Alexander Gavruskin
Bakhadyr Khoussainov
Mikhail Kokho
Jiamou Liu
Order of Authors Secondary Information:
Abstract: We study the dynamic scheduling problem for jobs with fixed start and end times on
multiple machines. The problem is to maintain an optimal schedule under the update
operations: insertions and deletions of jobs. Call the period of time in a schedule
between two consecutive jobs in a given machine an idle interval. We show that for any
set of jobs there exists a schedule such that the corresponding set of idle intervals
forms a tree under the set-theoretic inclusion. Based on this result, we provide a data
structure that updates the optimal schedule in O(d+log n) worst-case time, where d is
the depth of the set idle intervals and n is the number of jobs. Furthermore, we show
this bound to be tight for any data structure that maintains the nested set of idle
intervals.
Powered by Editorial Manager® and ProduXion Manager® from Aries Systems Corporation
Manuscript
Click here to download Manuscript: isaac_dyn_scheduling.tex
1
2
Algorithmica manuscript No.
3
(will be inserted by the editor)
4
5
6
7
8
Dynamic Algorithms for Multimachine Interval
9
10 Scheduling
11
12
A. Gavruskin · B. Khoussainov
13
14 M. Kokho · J. Liu
15
16
17
18
19
thedateofreceiptandacceptance shouldbeinsertedlater
20
21
22 Abstract Westudythedynamicschedulingproblemforjobswithfixedstart
23 and end times on multiple machines. The problem is to maintain an optimal
24 scheduleundertheupdateoperations:insertionsanddeletionsofjobs.Callthe
25
period of time in a schedule between two consecutive jobs in a given machine
26
an idle interval. We show that for any set of jobs there exists a schedule such
27
thatthecorrespondingsetofidleintervalsformsatreeundertheset-theoretic
28
inclusion. Based on this result, we provide a data structure that updates the
29
optimalscheduleinO(d+logn)worst-casetime,wheredisthedepthoftheset
30
idleintervalsandnisthenumberofjobs.Furthermore,weshowthisboundto
31
be tight for any data structure that maintains the nested set of idle intervals.
32
33
34
35 1 Introduction
36
37 Imagineanoperatorinadeliverycompanywithtworesponsibilities.Thefirst
38 is to provide delivery service to clients who requestspecific times for delivery.
39 The second is to schedule the requests for the drivers such that conflicting
40 requests are assigned to different drivers. The goal of operator’s work is to
41 accept all client requests and to use as few drivers as possible. The work
42 becomes harder if clients often cancel their requests or change the delivery
43
times of their requests.
44
The example above is a basic setup for the interval scheduling problem,
45
46 one of the well-known problems in the theory of scheduling [10,11]. Formally,
47 the problem can be described as follows. An interval a is the usual closed
48
AlexanderGavruskin,BakhadyrKhoussainov,MikhailKokho
49
TheUniversityofAuckland
50
E-mail:[email protected], [email protected], [email protected]
51
JiamouLiu
52
AucklandUniversityofTechnology
53
E-mail:[email protected]
54
55
56
57
58
59
60
61
62
63
64
65
1
2
3
2 A.Gavruskinetal.
4
5
6 non-emptyinterval[s(a),f(a)]onthe realline,wheres(a)isthe startingtime
7 and f(a) is the finishing time. Naturally, intervals represents jobs that have
8 to be completed in the specified periods. We say that two intervals a and b
9 overlap if a∩b 6= ∅; otherwise we say that they are compatible. We are given
10 a set I of n intervals. The problem is to partition I into sets S ,...,S such
1 k
11 thatintervals ineverysetS arepairwisecompatible andthe number k ofthe
i
12 setsisasminimalaspossible.Thepartitionofjobsrepresentschedulesforthe
13 machines.
14
15 Definition 1 A subset J ⊆ I is compatible if the intervals in J are pairwise
16 compatible.
17
18 Depending on the context, we view an interval a as either a process or as
19 a set of real numbers. In the first case, we call s(a) and f(a) respectively the
20 start and the end of a. In the second case, we refer to s(a) and f(a) as the
21 left and right endpoints of a. We define the depth of I, denoted by d(I), to
22 be the maximal number of intervals in I that containa common point. In the
23 context of machines, the depth of I is the maximal number of processes that
24 pass over any single point on the time line. We linearly orderelements in the
25 setI ofintervalsbytheirleftendpoints.Namely,wedefine the order≺onthe
26 set I by setting a≺b whenever s(a)<s(b) for all a,b∈I.
27
A scheduling function for the set of intervals I is a function σ : I →
28
{1,...,k} such that any two distinct intervals a,b∈ I where σ(a) = σ(b) are
29
compatible. The number k is called the size of the scheduling function. The
30
schedulingfunctionσ :I →{1,...,k}partitionsI intok schedules S ,...,S ,
31 1 k
where for each i∈{1,...,k} we have
32
33
S ={a∈I |σ(a)=i}.
34 i
35 It is easy to see that d(I) is the smallest size of any scheduling function of I.
36 This gives us the following important definition.
37
38 Definition 2 We call a scheduling function σ optimal if its size is d(I).
39
40 We briefly describe two algorithms solving the basic interval scheduling
41 problem. The standard greedy algorithm [7], which we call Algorithm 1, finds
42 an optimal scheduling function σ for the given set of intervals I as follows.
43 It starts with sorting the intervals in order of their starting time. Let a1, a2,
44 ..., a be the listing of the intervals in this order. Schedule a into the first
n 1
45 machine,thatis,setσ(a )=1.Then,for the giveninterval a andeachj <i,
1 i
46 if a and a overlap, exclude the machine σ(a ) for a . Schedule a into the
i j j i i
47 first machine m that has not been excluded for a and set σ(a ) = m. The
i i
48 correctnessproofofthisalgorithmisaneasyinduction[7].Thealgorithmruns
49 in O(n2)time. It is importantto observethatthis algorithmworksina static
50
context in the sense that the set of intervals I is given a priori and it is not
51
subject to change.
52
The second algorithm due to Gupta et al. [5], which we call Algorithm 2,
53
computes an optimal schedule in O(nlogn) time. Gupta et al. also show that
54
55
56
57
58
59
60
61
62
63
64
65
1
2
3
DynamicAlgorithmsforMultimachineIntervalScheduling 3
4
5
6 Algorithm 2 is the best possible. In this algorithm, we work with endpoints
7 of the intervals in I. Let p1,p2,...,p2n be endpoints of intervals sorted in
8 increasingorder.Scanthe endpointsfromlefttoright.Foreachpj,ifpj isthe
9 start of some interval a, find the first available machine and schedule a into
10 that machine. Otherwise, p is the end of some interval b. Therefore, mark
j
11 the machine σ(b) as available. The correctness of the algorithm can be easily
12 verified. Just as above, this algorithm works in a static context.
13
The problem setup. Our goal is to design data structures that allow
14
us to solve the interval scheduling problem in a dynamic setting. In the dy-
15
namiccontext,theinstanceoftheintervalschedulingproblemischangedbya
16
17 real-time events, and a previously optimal schedule may become sub-optimal.
18 Examples ofreal-time events include jobcancellation,the arrivalof anurgent
19 job,andchangesinjobprocessingtimes.Toavoidtherepetitiveworkofrerun-
20 ning the static algorithm every time when the problem instance has changed,
21 there isa demandforefficientdynamicalgorithmsforsolvingthe partitioning
22 problemonthechangedinstances.Inthisdynamiccontext,thesetofintervals
23 changesthroughanumber ofupdate operations,suchasinsertionorremoval.
24 Thus, the dynamic interval scheduling problem is the problem of maintaining
25 an optimal scheduling function σ for a set I of closed intervals, subject to
26
update operations. The update operations are
27
– insert(a): insert an interval a into the set I,
28
– delete(a): delete an interval a from the set I (if it is already there).
29
30 Contributionofthepaper.Therearethreemaintechnicalcontributions
31 of the paper. The first contribution concerns the concept of idle intervals. An
32 interval (t ,t ) is idle in a given schedule σ if some machine σ(k) stays idle
0 1
33 during the time period from t to t . Intuitively, an idle interval is a place in
0 1
34
the schedule where we can insert a new interval if its endpoints are between
35
t and t . Now, call the collection of all idle intervals nested if any two idle
0 1
36
intervals either have no points in common or one interval is included in the
37
other.Firstly,weproveinLemma3that nestedschedules arealwaysoptimal.
38
Secondly, we prove in Theorem 1 that there are optimal schedules for which
39
the set of idle intervals is nested. This theorem allows us to represent idle
40
intervalsofthe scheduleasatree,andperformthe updateoperationsthrough
41
maintainingtheidleintervalsoftheschedule.HerewenotethatDiedrichetal.
42
use idle intervals in[2],where they callthem gaps, to approximatealgorithms
43
44 forschedulingwithfixedjobs.In[2]idleintervalsarestaticanddonotdepend
45 on the schedule. On the contrary, we describe how to effectively maintain a
46 dynamic set of idle intervals.
47 Oursecondcontributionis thatwe provideanoptimaldatastructure that
48 represents nested schedules and supports insert and delete operations. The
49 data structure and its efficiency is based on Theorem 1. Namely, it maintains
50
thenestednesspropertyoftheschedules.Theorem2provesthatalltheupdate
51
operationsruninO(d+log(n))intheworst-case.Notethatifwenaivelymake
52
Algorithm 1orAlgorithm 2dynamic,theupdateoperationsofsuchalgorithms
53
will be significantly slower.
54
55
56
57
58
59
60
61
62
63
64
65
1
2
3
4 A.Gavruskinetal.
4
5
6 Finally, our third contribution is that we prove in Theorem 4 that the
7 boundO(d+log(n))istightforanydatastructurerepresentingnestedsched-
8 ules.
9
Relatedwork.Therearemanysurveysontheintervalschedulingproblem
10
anditsvariants,alsoknownas”k-coloringofintervals”,”channelassignment”,
11
”bandwidthallocation”andmanyothers.Forinstance,thereadercanconsult
12
surveys [10,11].GertsbakhandStern[4]studiedthebasicproblemofschedul-
13
14 ingintervalsonunlimitednumberofidenticalmachines.ArkinandSilverber[1]
15 describedandsolvedaweightedversionofthe intervalschedulingproblem.In
16 their workthe number ofmachinesis restrictedandeachjob hasa value.The
17 goal is to maximize the value of completed jobs. A further generalization of
18 theproblem,motivatedbymaintenanceofaircraft,wasextensivelystudiedby
19 Kroon, Salomon and Wassenhove [12,13] and by Kolen and Kroon [8,9]. In
20 this generalization, each job has a class, and each machine is of specific type.
21 The type of a machine specifies which classes of jobs it can process. Since it
22 wasshownin[1]thattheproblemofschedulingclassifiedjobsisNP-complete,
23 the authorsstudyapproximationalgorithms.Later,Spieksma[17]studiedthe
24
question of approximating generalized interval scheduling problem.
25
26
27
2 Idle Intervals and Nested Scheduling
28
29
2.1 Idle Intervals
30
31
Recall that we have the order ≺ on interval by their starting time. Our next
32
definition introduces the notionof idle intervalwhichis crucialfor this paper.
33
34 Definition 3 LetJ ={a ,a ,...,a }be acompatiblesetofclosedintervals
1 2 m
35 suchthata ≺a foreachi∈{1,...,m−1}. Definethesetofidle intervals
i i+1
36
of J as the following set
37
38 m−1
39 Idle(J)= {[f(a ),s(a )]}∪{[−∞,s(a )]}∪{[f(a ),∞]}.
[ i i+1 1 m
40 i=1
41
Note that an idle interval can start at −∞ or end at ∞. Naturally, such
42
intervals represent a period of time when a machine is continuously available
43
before or after some moment of time.
44
45 Let σ : I → {1,...,k} be a scheduling function of size k of the set I of
46 intervals.Recallthe sets S ,...,S withrespectto σ: S ={a∈I |σ(a)=i}.
1 k i
47 The idea behind considering the set of idle intervals is this: when we insert a
48 new interval a into I, we would like to find a gap in some schedule S that
i
49 fully covers a. Similarly, a deletion of an interval a from I creates a gap in
50
the schedule S . Thus, intuitively the insertion and deletion operations are
σ(a)
51
intimately related to the set of idle intervals of the current schedules S , ...,
1
52
S .Therefore,weneedtohaveamechanismthatefficientlymaintainstheidle
k
53
intervals of S , ..., S .
54 1 k
55
56
57
58
59
60
61
62
63
64
65
1
2
3
DynamicAlgorithmsforMultimachineIntervalScheduling 5
4
5
6 Definition 4 The set of idle intervals of σ is
7
Idle(σ)={[−∞,∞]}∪Idle(S )∪Idle(S )∪...∪Idle(S ).
1 2 k
8
9 Through the scheduling function σ, we can also enumerate the set of idle
10 intervals. Namely, the schedule number σ(b) of the idle interval b ∈ Idle(σ)
11 is i if b ∈ Idle(S ), and is k+1 if b = [−∞,∞]. The next lemma state that
i
12 the depth of the idle interval set is greater than or equal to the depth of the
13 interval set.
14
15 Lemma 1 We have d(I)≤k ≤d(Idle(σ)).
16 Proof For the first part, observe that for any sets of intervals I and J, the
17
following inequality holds true:
18
19 d(I)≤d(I ∪J)≤d(I)+d(J).
20
Since the depth of each schedule S is 1, we have
21 i
22 d(I)≤d(S ∪···∪S )≤ d(S )=k
23 1 k X i
1≤i≤k
24
Forthe secondpart,leta be the (cid:22)-leastintervalinthe schedule S .Then
25 i i
26 for each i∈ {1,...,k} an interval [−∞,s(ai)] belongs to Idle(σ). Now take a
27 real number x ∈ R that is smaller than all the starting times of the intervals
28 in I. In particular, x is smaller that the starting time of any ai. Thus x
29 intersects with k intervals in Idle(σ), i.e. k ≤d(Idle(σ)). ⊓⊔
30
Definition 5 A setJ ofintervalsis nestedif[−∞,∞]∈J andforall b ,b ∈
31 1 2
J, it is either that b covers b or b covers b or b ,b are compatible.
32 1 2 2 1 1 2
33 AnynestedsetofintervalsJ definesatreeunderset-theoreticinclusion⊆.
34 Indeed, here the nodes in the tree are the intervals in J, and an interval b
2
35 is a descendent of another interval b if b ⊂ b . We call this tree the nested
1 2 1
36 tree of J and denote it by Nest(J). We order siblings in Nest(J) by the left
37
endpointsofthecorrespondingintervals.Recallthatthe height ofatreeisthe
38
maximum number of edges in a path that goes from the root to any leaf.
39
40 Lemma 2 ForanynestedsetJ ofintervals,thedepthofJ equalstotheheight
41 of the nested tree Nest(J).
42
Proof LetJ be a nested setofintervals andh be the heightofthe nested tree
43
Nest(J). To show that d(J)≤h, we take a maximal path b ,b ,...,b in the
44 0 1 h
nestedtree.Inthispathb =[−∞,∞],andb ⊂b foralli∈{0,...,h−1}.
45 0 i+1 i
The interval b is fully covered by all other intervals. Therefore the starting
46 h
point s(b ) intersects with h intervals. Hence d(J)≤h
47 h
To show the reverse inequality, take any real number x ∈ R and let C be
48
49 the set of intervals in J that contain x. Since J is a nested set, C is a nested
50 set as well. Therefore C contains a sequence b1,b2,...,bℓ where bi ⊂ bi+1 for
51 all i ∈ {1,...,ℓ}. This sequence defines a single path in the tree Nest(J).
52 Thus h≤d(J). ⊓⊔
53
In the next subsection we connect idle interval sets with the nested trees.
54
55
56
57
58
59
60
61
62
63
64
65
1
2
3
6 A.Gavruskinetal.
4
5
6 S1:
7
S2:
8
9 Fig. 1 Dotted linesdefinetheidleintervalset
10
11
12 2.2 Nested Scheduling
13
14 Definition 6 Let σ be a scheduling function of the set of intervals I. We say
15 that σ is nested schedule if the set Idle(σ) of idle intervals is nested.
16
17 The next lemma showsthe usefulness of the notionof nested schedules.In
18 particular, nested schedules are optimal.
19
20 Lemma 3 If σ : I → {1,...,k} is a nested scheduling function, then the
21 depth of the idle intervals Idle(σ) coincides with the depth of I. In particular,
22 every nested schedule is optimal.
23
24 Proof Let σ : I → {1,...,k} be a nested scheduling function for I. By
25 Lemma 1, d(I)≤d(Idle(σ)). To show that d(Idle(σ))≤d(I), by Lemma 2, it
26 is sufficient to prove that the height h of the nested tree Nest(Idle(σ)) is at
27 most d(I).
28 Take a maximal path b ,b ,...,b in Nest(Idle(σ)) such that f(b ) 6= ∞.
0 1 h 1
29 For each i ∈ {1,...,h} let S be a schedule such that b ∈ Idle(S ). We show
i i i
30
that in every schedule S there exists an interval a ∈ S such that f(b )
i i i 1
31
intersects with a .
i
32
For contradiction, assume that there exists a schedule S such that f(b )
33 j 1
does not intersect with any interval in S . Then there exists an idle interval
34 j
c ∈ Idle(S ) such that f(b ) ∈ c. Therefore s(c) < f(b ). On the other hand,
35 j 1 1
since b ∈ Idle(S ), we have s(b ) < f(b ) < s(c). These imply that the idle
36 j j 1 j
intervals b and c overlap, which contradicts with the fact that Idle(σ) is a
37 1
nested schedule. Thus h is at most d(I). ⊓⊔
38
39
AnaturalquestioniswhetherthescheduleconstructedbyeitherAlgorithm
40
41 1 or Algorithm 2 is nested. The next simple example gives a negative answer
42 to this question. Indeed, consider the set I of intervals presented in Figure 1.
43 Both algorithms yield the same scheduling, which is not nested:
44 In the next section, however, we prove that every interval set I possesses
45 a nested scheduling.
46
47
48 2.3 Extending Nestedness
49
50
Oneofthe goalsofthissectionistoprovethateveryintervalsetI possessesa
51
nestedscheduling.Theproofwillalsoprovideamethod,explainedinthenext
52
section, that maintains the interval set I by keeping the nestedness property
53
invariant under the update operations.
54
55
56
57
58
59
60
61
62
63
64
65
1
2
3
DynamicAlgorithmsforMultimachineIntervalScheduling 7
4
5
a
6
7
8
9 z zℓ a zr
10
11
12
Fig. 2 Reschedulingwhenadoes notoverlapwithidleintervals
13
14
15 Suppose that σ : I → {1,...,k} is a nested scheduling function for the
16 interval set I. Recall that we use S ,...,S to denote the k schedules with
1 k
17 respect to σ. Let a be a new interval not in I. We introduce the following
18 notations and make several observations to give some intuition to the reader.
19
– Let L ⊂ Idle(σ) be the set of all the idle intervals that contain s(a), but
20
21 do not cover a. The set L, as Idle(σ) is nested, is a sequence of embedded
22 intervals x1 ⊃···⊃xℓ, where ℓ≥1. Note that L can be the empty set.
23 – Let R ⊂ Idle(σ) be the set of all the idle intervals that contain f(a), but
24 do not cover a. The set R, as above, is a sequence of embedded intervals
25 y ⊃···⊃y , where r ≥1. Again, R can be empty as well.
1 r
26 – LetzbetheshortestintervalinIdle(σ)thatcoversa.Suchanintervalexists
27 since [−∞,∞]∈Idle(σ). To simplify the presentation,we set x =y =z.
0 0
28 Note that x ⊃x and y ⊃y .
0 1 0 1
29
Now our goal is to construct a new nested schedule based on σ and the
30
31 content of the sets L and R. For that we consider several cases.
32
Case 1: L and R are empty sets
33
In this case we can easily extend σ to the domain I ∪{a} and preserve
34
the nestedness property. Indeed, as a ⊂ z, we simply extend σ by setting
35
σ(a)=σ(z). We show that the resulted schedule is nested.
36
After insertion of a, the idle interval z is split into two intervals z =
37 ℓ
[s(z),s(a)] and z = [f(a),f(z)]. Consider an arbitrary idle interval u in
38 r
Idle(σ). If u and z are compatible then u is compatible with both z and
39 r
z . If z ⊂u then the intervals z and z are now coveredby u. If z ⊃u then u
40 ℓ ℓ r
41 iseithercoveredbyzℓ orzr,orudoesnotintersectwiththenewidleintervals.
42 ThuCsatshee r2e:suLltiisngnsoetteomf ipdltey,inbteurtvaRls=is∅nested. See an example in Figure 2.
43 If we simply set σ(a)=σ(z) as in the previous case, some of the intervals
44 in the new idle set will be overlapping. For example, the new idle interval
45 [s(z),s(a)] will intersect with x . Therefore we reorganize the schedule σ as
1
46 follows.
47 Wescheduleintervalaforthemachineσ(x ).Wemoveallthejobsdofthe
ℓ
48 machine σ(x ) such that d≻x to machine σ(x ). In the schedule S
ℓ ℓ ℓ−1 σ(xℓ−1)
49 there are other jobs that start after x . To avoid collisions, we move these
ℓ−1
50
jobs to the machine σ(x ). We continue this on until we reach the jobs
ℓ−2
51
scheduledforthe machineσ(z). Finally,we movethe jobs dfromthe machine
52
σ(z) such that d ≻ z to the machine σ(x ). Note that if f(z) = +∞ there is
ℓ
53
simply no jobs on the machine σ(z) to reschedule. Example of this process is
54
55
56
57
58
59
60
61
62
63
64
65
1
2
3
8 A.Gavruskinetal.
4
5
a
6
7 x2 x′2 a
8
9 x1 x′1
10
11 x0=z z′
12
Fig. 3 Reschedulingwhenidleintervalsoverlappingacontains onlys(a)
13
14
15 onFigure3.Formally,wedefinethenewschedulingfunctionσ asfollowsand
1
16 claim that σ is nested:
1
17
18 σ(x ) if d=a, or
 ℓ
19
2201 σ1(d)=σ(xi−1) σif(σd)(d=)=σ(σz)(xain)dandd≻dz≻, xi,
22 where 0<i≤ℓ,
2234 σ(d) otherwise.
Claim A. The scheduling σ defined is nested.
25 1
26
Proof Thesetofidle intervalsIdle(σ )consistsofthe newinterval[f(a),f(z)]
1
27
together with all the idle intervals of σ where the idle intervals x , x ,
28 ℓ ℓ−1
..., x , and z are changed to the following new idle intervals [s(x ),s(a)],
29 1 ℓ
[s(x ),f(x )], ..., [s(x ),f(x )], and [s(z),f(x )], respectively. We denote
30 ℓ−1 ℓ 1 2 1
the set of changed intervals by L′.
31
Letuandvbetwoidleintervalsofσ .Wewanttoshowthateitheru∩v =∅
32 1
or one of these two intervals is contained in the other. If both u and v are old
33
34 or both u and v are new then we are done. So, say u is new, and v is old.
35 First,assumethatuis[f(a),f(z)].BecausebyassumptionR=∅,theinterval
36 v either coversa or does not intersect with a. In the first case, u⊂v, because
37 we have chosen z such that z ⊂ v. In the second case, if f(v) < s(a) then v
38 andudoesnotintersect.If s(v)>f(a)then,becauseIdle(σ) wasanestedset
39 of intervals, we have that either v ⊂u or u∩v =∅.
40 Second, assume u is one of the changed intervals in L′ and v is an old idle
41 interval. If v contains s(a) then v must contain z since v is old. Hence u⊂v.
42 Otherwise,supposethatvcontainsapointr ∈[s(x ),f(x )]orr ∈[s(x ),s(a)].
i i+1 ℓ
43 Then either r ∈ x or r ∈ x . Hence, v ⊂ x or v ⊂ x . If the first case
i i+1 i i+1
44
we have v ⊂[s(x ),s(a)], and in the second case v ⊂[s(a),f(x )]. In either
i i+1
45
case, v ⊂[s(x ),f(x )]. This proves the claim. ⊓⊔
i i+1
46
47 Case 3: The set R is not empty, but L=∅
48 This case is symmetric to the previous case: we need to reorganize the
49 intervals, but we reorganize the intervals with respect to the finishing time
50
of the new interval a. First, we set σ(a) equal to σ(z). The new idle interval
51
(f(a),f(z)) now intersects with idle intervals y ,...,y . Therefore for every
1 r
52
1 ≤ i < r we move intervals from the machine σ(y ) that start after y to
i i
53
the next machine σ(y ). To avoid collision on the last machine σ(y ) we
54 i+1 r
55
56
57
58
59
60
61
62
63
64
65