1. Reservation Systems TimeTabling
Week 6
10 maart 2004
Reservation Systems TimeTabling
1. Reservation Systems without Slack
2. Reservation Systems with Slack
3. Timetabling with Tooling Constraints
4. Timetabling with Recourse Constraints
5. Scheduling flights at the airport
Operations Scheduling

2. Relation between these problems
1. Reservation Systems without Slack (timing of job is fixed)
m Parallel machines, n jobs (fixed in time; interval scheduling)
2. Reservation Systems with Slack
m Parallel machines, n jobs (more flexible in time)
3. Timetabling with Tooling Constraints
Enough identical machines in parallel, n jobs, tools (only 1 of each avail.)
4. Timetabling with Resource Constraints
Enough identical machines in parallel, n jobs, one resource

3. Reservation Systems without Slack (Interval Scheduling)
Topic 1
Reservation Systems without Slack
(Interval Scheduling)

4. Reservation without Slack
Week 6
Reservation without Slack
10 maart 2004
Reservation system with m machines, n jobs
Release date rj (integer), due date dj (integer), weight wj
No slack If accepted, job starts at time rj
Can we accept all jobs? Do we need all machines?
objective1: Maximize number of jobs processed OR
objective2: Minimize number of machines needed for all jobs
Operations Scheduling

5. ILP Problem Formulation
e.g. at car-rental: hi pj
Integer Program
Fixed time periods, assume H periods
Binary variables xij (=1 if job j assigned to i th machine, 0 otherwise)
Job requiring
processing in
period l
Jl ={j| rj l  dj }
Exercise 1: How to adapt model for: do all jobs, but on a minimum number of machines

6. Maximizing value of processed jobs
In general is NP-hard (when both pj and wij free)
Two special cases with exact algorithms
each of these algorithms sorts the jobs to increasing rj
Case 1: processing times pj = 1
decompose into separate time units
assign in each time unit most valuable jobs first

7. Case 2: Identical Weights and Machines
Mj = {1,2,…,m} with wij = 1
objective: maximize #jobs taken
(No time decomposition, but still) an exact, simple algorithm:
Dispatch jobs, tentatively, in order of increasing release date
when next job has no machine while being earlier completed, select it at the expense of the later completed scheduled job

8. Algorithm (case 2: Identical Weights and Machines)
Step 1
Set J =  and j = // J as set of accepted jobs
Step 2
If available at time rj assign job j to a machine, include j in J, go to Step 4
Step 3
Of scheduled job set J, select j* with latest finish
If do not include j in J and go to Step 4
Else delete job j* from J, assign j to freed machine & include in J
Step 4
If j = N STOP, select next job j = j+1 and go back to Step 2

9. Minimizing #machines used
No slack, arbitrary processing times, equal weights, infinitely many identical machines in parallel
Easily solved, as follows
Order jobs as before to earliest release date
Assign job 1 to machine 1
Suppose first j-1 jobs have been assigned for processing
Try to assign j th job to a machine i ( j-1) as already used
If not possible assign to a new machine
Special case of node coloring problem
Why special case? (to be discussed later..)

10. Reservation Systems with Slack
Summary Reservation Systems without Slack
Maximize # of jobs processed: simple algorithm
Minimize # of machines needed: simple algorithm
Topic 2
Reservation Systems with Slack

11. Reservation with Slack
Now allow slack (time slots)
Considering three cases with identical machines
and objective: maximize #jobs
Case 0. All processing times pj = 1 (trivial solution)
Case 1. All processing times pj = p  2 , identical weights
Case 2. General processing times, weights wj

12. Case 1: Equal Processing Times
Now assume processing times all equal to some p  2
NOTE: slack can be different
Interaction between time units
Method: Barriers algorithm
wait for critical jobs to be released
start the job with the earliest deadline
Slot number l = l th job to start
S(l) starting time of l th slot

13. Barriers Algorithm
Barriers Algorithm (again open, whether this algorithm is exact!)
Barrier
ordered pair (l, r)
Expresses waiting constraint
Approach: Starting with a k-partial schedule
construct a (k+1)-partial schedule
or add a new barrier to the barrier list Lb and start over from scratch
Slot
number
Release
time

14. Earliest Deadline with Barriers
Selects machine h for job in (k+1)th slot
Compute the starting time

15. Computing the Starting Time
t is defined as the earliest time that the next job can start
Claim:
Minimum
release date
of jobs left

16. Job in (k+1)th slot, can be a crisis job
Choose for (k+1)th slot: among available jobs, j ’ with earliest dj’
The creation of (k+1)-partial-schedule is successful if
Otherwise, job j ’ is a ‘crisis job’ and one calls upon the
Backtrack l=k, k-1, .. seeking 'pull-job' jl with dj(l) > dj'
(most recently scheduled with later deadline than job j' )
If no pull-job is found, then exclude the crisis job
Otherwise:
Add barrier (l, r*) in Lb, with r* min. release time in restricted set Jr , of jobs in part. sched. after pull job
Start anew with the updated barrier list
Crisis Routine

17. Barriers Algorithm: an example (all pj=10)
Machine 1
Machine 2 1 2 3
Crisis job
Pull job (d2 > d3)

18. An example (cont’d)
Slot k=3 gives crisis job j=3 with pull job 2 in slot l=2
Setup restricted set: Jr={3} (min. release date r* = r3= 5)
Include new barrier: (l, r*) = (2,5)  Lb
Restart with updated list Lb from scratch (with extra wait command)
Crisis job
Now at k=2, wait till
M 1
M 2 1 3 1 2 3 4 2
Pull job (d2 > d3)
Optimal schedule t

19. CASE 2: General processing times
Reservation with slack: processing times pj and weights wj
NP-hard 
No efficient algorithm 
Heuristic needed
Composite dispatching rule
Preprocessing: determine flexibility of jobs and machines
Dispatch least flexible job first on the least flexible machine, etc

20. Defining priority indices
yik := # candidate jobs on machine i in time slot [k-1,k]
|Mj|= # machines suitable for job j
Priority index Ij for jobs (lower index =higher priority):
more value | less proc. | less machines  lower index Ij
Priority index gi k j of using machine i for job j in interval [k, k+pj]

21. Algorithm 1: - Calculate both priority indices Ij and yik
- Order jobs according to job priority index (Ij)
- Set j = 1
2: - Among available machines and time slots assign j to the
combination <machine i , [k,k+pj] > with lowest value gikj
- Discard job j if it cannot be processed at all
3: - If j = n then STOP, otherwise go back to Step 2 with j = j+1

22. Timetabling with Tooling Constraints
Summary Reservation Systems with Slack
Equal processing times: Barrier algorithm
General processing times : Composite dispatching rule
Topic 3
Timetabling with Tooling Constraints

23. Timetabling (All given) n jobs must be processed
enough (e.g. >= n) identical machines in parallel
Minimizing Makespan
Tooling Constraints
Set of different available tools k (say in set K ):
of each k, only one available (for use by one job at a time)
Job j requires tools of subset Kj during its processing
Timetabling is Special Case of RCPSP :
no precedence constraints
Rk = 1; rjk=1 or 0 depending on k being part of Kj

24. Why Timetabling = Node coloring
Example: all jobs take one time unit 7 1 4 3 2 5 6
Job = node;
Jobs need same tool  arc
between nodes
Makespan <= H time units ?
 Can graph be colored
with  H colors ?

25. Node Coloring Problem
Consider a graph with n nodes that are to be colored
For any arc (j,k) nodes j and k cannot receive the same color
Feasibility question:
Can the graph be colored with m (or less) colors?
Optimality question:
Minimum #colors needed to color the graph?

26. Heuristic for Node Coloring
Terminology
degree of node = number of arcs connected to node
saturation level = number of colors connected to node
Intuition
Color high degree nodes first
Color high saturation level nodes first

27. Heuristic Algorithm for Node Coloring
Step 1: Order nodes in decreasing order of degree
Step 2: Use color 1 for first node
Step 3: Choose uncolored node with maximum saturation
level, breaking ties according to degree
Step 4: Color using the lowest possible color-number
Step 5: If all nodes colored, STOP;
otherwise go back to Step 3

28. Example book
Nodes
Degree 1 7 2 6 3 5 4

29. Example book
Saturation + Degree in uncolored subgraph = Degree original graph
Nodes
Degree sub
Saturation 1 7 2 6 3 5 4

30. Example book
Nodes
Degree sub
Saturation 1 7 2 6 3 5 4

31. Example book
Nodes
Degree sub
Saturation 1 7 2 6 3 5 4

32. Example book
Nodes
Degree sub
Saturation 1
Result 4 colors
e.g.
7: blue
2: red or green
6: yellow or green 7 2 6 3 5 4

33. Worse: a reverse method6
Degree sub
Nodes
Degree 1 1 7 7 2 2 6 3 3 5 4 4

34. Example of Timetabling with tools
For solution: see previous node coloring example.
Job 1: yellow
Job 3: blue
Job 7: blue
Job 4: green
Job 5: red
Job 2: red or green
Job 6: yellow or green

35. Relation to Reservation Models
Closely related to reservation problem with zero slack and arbitrary processing times (interval scheduling)
Interval scheduling = Special case of timetabling problem
jobs with common time periods  unary (pj=1) jobs with common tools
new color = new machine  new color = extra period
job occupies adjacent time periods (creating easy solvable color problem) 
jobs occupy tools ‘that need not be adjacent’

36. Example Suppose now we have a reservation system
Here we transform to time-tabling:
Job 1 must
be processed
in time [0,2]
Job 2 must
in time [2,5]

37. Other example Adjusted example of Timetabling with tools
Rearrange and rename tools
jobs 1 2 3 4 5 6 7
Tool 1 1 1 1 1 1 1
Tool 2 1 1 1
Tool 3 1 1 1
Tool 4 1 1 1 1
Period 1
Period 2
Period 3
Period 4

38. Timetabling with Resource Constraints
Summary Timetabling with Tooling Constraints
Node Coloring heuristic
Topic 4
Timetabling with Resource Constraints

39. Timetabling with single resource
Unlimited number of identical machines in parallel
All n jobs must be processed
Resource constraints
Single resource of total quantity R
Required is a certain amount for each job

40. Resource Constraints One type of tool but R units of it (resource)
Job j needs Rj units of this resource
Clearly, if Rj + Rk > R then job j and k cannot be processed at the same time, etc
Applications
scheduling a construction project (R = crew size)
exam scheduling (R = number of seats)
Special case of RCPSP with one resource, pi  1, no precedence

41. Special case: Bin-Packing
Assume equal processing times pj = 1
Unlimited number of machines
Minimize makespan
Equivalent to bin-packing problem
each bin has capacity R
item of size rj
pack into the minimum number of bins

42. Solving the Bin-Packing Problem
Known to be NP-hard
Many heuristics developed
First fit (FF) heuristic
Always put an item in the first bin it fits into
Know that

43. Example Assume 18 items and R = 2100 FF heuristic:
Jobs 1-6 require 301 resources
Jobs 7-12 require 701 resources
Jobs require 1051 resources
FF heuristic:
We assign the first 6 jobs to one interval (3016=1806)
We then assign jobs two at a time to next 3 intervals (7012=1402)
We then assign just one of the remaining jobs to each interval
Poor performance when jobs are assigned in arbitrary order

44. First Fit Decreasing (FFD)
An improvement of FF:
Order jobs in decreasing order first
Know that
FF and FFD can be extended to different release dates
R = 12
6 jobs of size 6, 4, 4, 4, 3, 3

45. Discussion This chapter only considered very simple models
In practice:
Dynamic reservation systems
Price considerations (yield management)
Other requirements (such as in final topic..)

46. Extra Topic: Scheduling flights at the airport,
A reservation problem with no slack :
When planning check-in desks
(as adjacent tools)

47. Planning Check-in Desks
rj = # desks required during (given) time-interval I(j) for flights j=1,2,..n
Optimization Problem
- Minimize total #desks R* for all flight-desk -assignments
Distinguishing feature:
- Assigned desks must be adjacent

48. Algorithm: Earliest Release Date or First-Fit (analogous to algorithm for minimum #machines, topic 1 )
Flight 5 does not fit

49. Find better solutions with R < 11!
Another Example Scheduling flights (j=1,2,..8) in 30 min. periods (t=1,2,..9)
Data:
A feasible, but non-optimal solution: LH
Find better solutions with R < 11!

50. First attempt Define R(t) as sum of rj’s over jobs j with tÎI(j)
Then R* >= max t R(t) (a lower bound called Rlow)

51. Optimal Assignment with R*=8 desks
Here Rlow=8 and R* = Rlow

52. Question: Always R* = Rlow ?
Exercise 2: find a schedule using only #desk-rows 9=Rlow

53. Optimal solution with R*=Rlow=9
What if new flight 12 has r(12)=3 in interval 3-3 ?
Answer: R* > Rlow is possible

54. Complexity NP-complete Partition problem: Solve Partition by :
If ‘vertical jobs’ require resp. : G+2, G+2, G+1, G, 2G+1, 2G+3 desks
Then again: an optimal solution must have two holes of size G at t=3
NP-complete Partition problem:
given
Numbers g1,g2,.., gn
with total sum 2G
question
Are there 2 subsets
each with sum G
Solve Partition
by :
- adding jobs j=11+i
for i=1,2..n
with r(11+i)=gi
(and I(j)=[3,3])
- observe
if R*=2G+5

55. Notation for an ILP model
Ij (= [aj .. bj ]) Check-in interval
rj # of desks required
dj Largest number of adjacent desks as occupied by j
desks d f
flight f d g
flight g 1
period a a b b f g f g

56. Exercise 3: Finish this ILP model
With integer variables:
D : Total number of desks required
dj : Largest desk number assigned to flight j
With parameters:
rj : Number of desks required for the check-in process of flight j
Ij : Check-in time interval of flight j
Hint: disjunctive model, comparable to that for job-shop-scheduling

57. An alternative ILP model
Binaries yj t r (=1 if j occupies in period t largest desk r; 0 otherwise)
Flight j require n(j,t) adjacent desks in period t
Exercise 4: model the missing constraint-set
Hint: similar to the technique used in the RCSP model

58. With n(j,t) desks for a flight
Static
Dynamic (8 possible shapes)
or or or …