JOB SEQUENCING WITH

DEADLINES
The problem is stated as below.
• There are n jobs to be processed on a machine.
• Each job i has a deadline di≥ 0 and profit pi≥0 .
• Pi is earned iff the job is completed by its deadline.
• The job is completed if it is processed on a machine
for unit time.
• Only one machine is available for processing jobs.
• Only one job is processed at a time on the machine.
1
 JOB SEQUENCING WITH
DEADLINES (Contd..)
• A feasible solution is a subset of jobs J such that
each job is completed by its deadline.
• An optimal solution is a feasible solution with
maximum profit value.
Example : Let n = 4, (p1,p2,p3,p4) = (100,10,15,27),
(d1,d2,d3,d4) = (2,1,2,1)

2
 JOB SEQUENCING WITH
DEADLINES (Contd..)
Sr.No. Feasible Processing Profit value
Solution Sequence
(i) (1,2) (2,1) 110
(ii) (1,3) (1,3) or (3,1) 115
(iii) (1,4) (4,1) 127 is the optimal one
(iv) (2,3) (2,3) 25
(v) (3,4) (4,3) 42
(vi) (1) (1) 100
(vii) (2) (2) 10
(viii) (3) (3) 15
(ix) (4) (4) 27
3
 Algorithm: GreedyJob (d, J, n)
• { // Jobs are arranged in decreasing order of profits.
• // J is a set of jobs that can be completed
• // by their deadlines.
• J = {empty set};
• // Initialize J as an empty set
• for i = 1 to n do
• { if (all jobs in J U {i} can be completed by their
deadlines)
• then J = J + {i}; // Add job i to the set J } }

4
 Q.
Profit
Job Deadline (di) (Pi)
J1 1 100
J2 2 10
J3 2 15
J4 2 27
Sort by Profit (Decreasing): The jobs are rearranged based on
profit in descending order.
Deadline Profit
Job (di) (Pi)
J1 1 100
J4 2 27
J3 2 15
J2 2 10 5
•Select Maximum Deadline: The maximum deadline among all jobs is identified as 2.
•This indicates the total number of slots available for scheduling.
•Greedy Selection:
•Job J1: Deadline is 1, which fits within the available slots. It's selected and contributes a profit
of 100.
•Job J4: Deadline is 2, which also fits within the available slots. It's selected and adds a profit of
27.
•Job J3: Deadline is 2, but the slot for deadline 2 is already occupied by J4. Therefore, J3 is
skipped.
•Job J2: Deadline is 2, but the slot for deadline 2 is already occupied by J4. Therefore, J2 is
skipped

Job Deadline (di) Profit (Pi)

J1 1 100
J4 2 27

Total Profit Earned: 100 + 27 = 127

6
Q. Job
J7
J3
Profit
30
20
Deadline
2
4
J4 18 3
J6 6 1
J2 5 3
J1 3 1
J5 0 2

Sorting by Profit (Descending):

The first step, as mentioned in the text, is to sort the jobs in descending order of
their profit values.
Job Profit Deadline
J7 30 2
J3 20 4
J4 18 3
J6 6 1
J2 5 3
J1 3 1
7
J5 0 2
Q. Job Profit Deadline
J7 30 2
J3 20 4
J4 1 3
J6 6 1
J2 5 3
J1 3 1
J5 0 2

Job Profit Deadline

Q.
J7 30 2
J3 25 4
J4 18 3
J6 6 1
J2 5 3
J1 3 1
J5 0 2
8
. Determining the Maximum Deadline:
The maximum deadline (d) among all jobs is identified as 4. This signifies that we have
time slots available for scheduling the jobs (from 1 to 4).
Greedy Job Selection:
Now, we iterate through the sorted jobs and select them if they can be
scheduled within their deadlines without overlapping.
•Job J7: Profit = 30, Deadline = 2. It can be scheduled in slot 2.
•Job J3: Profit = 20, Deadline = 4. It can be scheduled in slot 4.
•Job J4: Profit = 18, Deadline = 3. It can be scheduled in slot 3.
•Job J6: Profit = 6, Deadline = 1. It can be scheduled in slot 1.
•Job J2: Profit = 5, Deadline = 3. Cannot be scheduled. Slot 3 is
already occupied by J4.
•Job J1: Profit = 3, Deadline = 1. Cannot be scheduled. Slot 1 is
already occupied by J6.
•Job J5: Profit = 0, Deadline = 2. Cannot be scheduled. Slot 2 is
already occupied by J7.
9
Scheduled Jobs and Profits:
•Job J7: Profit = 30
•Job J3: Profit = 20
•Job J4: Profit = 18
•Job J6: Profit = 6
Total Profit: 30 + 20 + 18 + 6 = 74

10
 GREEDY ALGORITHM TO
OBTAIN AN OPTIMAL SOLUTION
• Consider the jobs in the non increasing
order of profits subject to the constraint that
the resulting job sequence J is a feasible
solution.
• In the example considered before, the non-
increasing profit vector is
(100 27 15 10) (2 1 2 1)
p1 p4 p3 p2 d1 d4 d3 d2
11
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

J = { 1} is a feasible one
J = { 1, 4} is a feasible one with processing
sequence
( 4,1)
J = { 1, 3, 4} is not feasible
J = { 1, 2, 4} is not feasible
J = { 1, 4} is optimal

12
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

Theorem: Let J be a set of K jobs and

 = (i1,i2,….ik) be a permutation of jobs in J
such that di1 ≤ di2 ≤…≤ dik.
• J is a feasible solution iff the jobs in J can
be processed in the order  without
violating any deadly.

13
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)
Proof:
• By definition of the feasible solution if the
jobs in J can be processed in the order
without violating any deadline then J is a
feasible solution.
• So, we have only to prove that if J is a
feasible one, then  represents a possible
order in which the jobs may be processed.

14
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

• Suppose J is a feasible solution. Then there

exists 1 = (r1,r2,…,rk) such that
drj  j, 1  j <k
i.e. dr1 1, dr2  2, …, drk  k.
each job requiring an unit time.

15
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

  = (i1,i2,…,ik) and 1 = (r1,r2,…,rk)

• Assume  1  . Then let a be the least
index in which  1 and  differ. i.e. a is such
that ra  ia.
• Let rb = ia, so b > a (because for all indices j
less than a rj = ij).
• In  1 interchange ra and rb.
16
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

 = (i1,i2,… ia ib ik ) [rb occurs before ra

in i1,i2,…,ik]
 1 = (r1,r2,… ra rb … rk )
i1=r1, i2=r2,…ia-1= ra-1, ia  rb but ia = rb

17
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

• We know di1  di2  … dia  dib …  dik.

• Since ia = rb, drb  dra or dra  drb.
• In the feasible solution dra  a drb  b
• So if we interchange ra and rb, the resulting
permutation 11= (s1, … sk) represents an
order with the least index in which 11 and 
differ is incremented by one.
18
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

• Also the jobs in 11 may be processed

without violating a deadline.
• Continuing in this way, 1 can be
transformed into  without violating any
deadline.
• Hence the theorem is proved.

19
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)
• Theorem2:The Greedy method obtains an optimal
solution to the job sequencing problem.
• Proof: Let(pi, di) 1in define any instance of the
job sequencing problem.
• Let I be the set of jobs selected by the greedy
method.
• Let J be the set of jobs in an optimal solution.
• Let us assume I≠J .

20
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

• If J C I then J cannot be optimal, because

less number of jobs gives less profit which
is not true for optimal solution.
• Also, I C J is ruled out by the nature of the
Greedy method. (Greedy method selects
jobs (i) according to maximum profit order
and (ii) All jobs that can be finished before
dead line are included).
21
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)
• So, there exists jobs a and b such that aI,
aJ, bJ,bI.
• Let a be a highest profit job such that aI,
aJ.
• It follows from the greedy method that p a
 pb for all jobs bJ,bI. (If pb > pa then
the Greedy method would consider job b
before job a and include it in I).
22
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)
• Let Si and Sj be feasible schedules for job
sets I and J respectively.
• Let i be a job such that iI and iJ.
(i.e. i is a job that belongs to the schedules
generated by the Greedy method and
optimal solution).
• Let i be scheduled from t to t+1 in S I and
t1to t1+1 in Sj.
23
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)
• If t < t1, we may interchange the job scheduled in [t 1
t1+1] in SI with i; if no job is scheduled in [t 1 t1+1] in SI
then i is moved to that interval.
• With this, i will be scheduled at the same time in S I and
SJ.
• The resulting schedule is also feasible.
• If t1 < t, then a similar transformation may be made in S j.
• In this way, we can obtain schedules S I1 and SJ1 with the
property that all the jobs common to I and J are
scheduled at the same time.
24
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)
• Consider the interval [Ta Ta+1] in SI1 in which the
job a is scheduled.
• Let b be the job scheduled in Sj1 in this interval.
• As a is the highest profit job, pa  pb.
• Scheduling job a from ta to ta+1 in Sj1 and
discarding job b gives us a feasible schedule for
job set J1 = J-{b} U {a}. Clearly J1 has a profit
value no less than that of J and differs from in one
less job than does J.
25
GREEDY ALGORITHM TO OBTAIN AN
OPTIMAL SOLUTION (Contd..)

• i.e., J1 and I differ by m-1 jobs if J and I

differ from m jobs.
• By repeatedly using the transformation, J
can be transformed into I with no decrease
in profit value.
• Hence I must also be optimal.

26
 GREEDY ALGORITHM FOR JOB
SEQUENSING WITH DEADLINE
Procedure greedy job (D, J, n) J may be represented by
// J is the set of n jobs to be completed// one dimensional array J (1: K)
// by their deadlines // The deadlines are
J {1} D (J(1))  D(J(2))  ..  D(J(K))
for I  2 to n do To test if JU {i} is feasible,
If all jobs in JU{i} can be completed we insert i into J and verify
by their deadlines D(J®)  r 1  r  k+1
then J  JU{I}
end if
repeat
end greedy-job

27
 GREEDY ALGORITHM FOR
SEQUENCING UNIT TIME JOBS
Procedure JS(D,J,n,k)
// D(i)  1, 1 i  n are the deadlines //
// the jobs are ordered such that //
// p1  p2  …….  pn //
// in the optimal solution ,D(J(i)  D(J(i+1)) //
// 1  i  k //
integer D(o:n), J(o:n), i, k, n, r
D(0) J(0)  0
// J(0) is a fictious job with D(0) = 0 //
K1; J(1) 1 // job one is inserted into J //
for i 2 to do // consider jobs in non increasing order of pi //28
 GREEDY ALGORITHM FOR
SEQUENCING UNIT TIME JOBS (Contd..)
// find the position of i and check feasibility of insertion //
r k // r and k are indices for existing job in J //
// find r such that i can be inserted after r //
while D(J(r)) > D(i) and D(i) ≠ r do
// job r can be processed after i and //
// deadline of job r is not exactly r //
r r-1 // consider whether job r-1 can be processed after i //
repeat

29
 GREEDY ALGORITHM FOR
SEQUENCING UNIT TIME JOBS (Contd..)

if D(J(r))  d(i) and D(i) > r then

// the new job i can come after existing job r;
insert i into J at position r+1 //
for I  k to r+1 by –1 do
J(I+1) J(l) // shift jobs( r+1) to k right by//
//one position //
repeat
30
 GREEDY ALGORITHM FOR
SEQUENCING UNIT TIME JOBS (Contd..)
J(r+1)i ; k k+1
// i is inserted at position r+1 //
// and total jobs in J are increased by one //
repeat
end JS

31
 COMPLEXITY ANALYSIS
OF JS ALGORITHM
• Let n be the number of jobs and s be the number of
jobs included in the solution.
• The loop between lines 4-15 (the for-loop) is
iterated (n-1)times.
• Each iteration takes O(k) where k is the number of
existing jobs.
 The time needed by the algorithm is 0(sn) s  n so
the worst case time is 0(n2).
If di = n - i+1 1  i  n, JS takes θ(n2) time
D and J need θ(s) amount of space.
32
 A FASTER
IMPLEMENTATION OF JS
• The time of JS can be reduced from 0(n 2) to
0(n) by using SET UNION and FIND
algorithms and using a better method to
determine the feasibility of a partial
solution.
• If J is a feasible subset of jobs, we can
determine the processing time for each of
the jobs using the following rule.
33
A FASTER IMPLEMENTATION OF
JS (Contd..)
• If job I has not been assigned a processing time,
then assign it to slot [ -1, ] where  is the
largest integer r such that 1  r  di and the slot [
-1, ] is free.
• This rule delays the processing of jobs i as much
as possible, without need to move the existing jobs
in order to accommodate the new job.
• If there is no , the new job is not included.

34
A FASTER IMPLEMENTATION OF
JS (Contd..)
EXAMPLE: let n = 5, (p1,--------p5) = (20,15,10,5,1) and (d1,--d5) =
(2,2,1,3,3). Using the above rule
J assigned slot jobs being considered action or
Ø none 1 assigned to [1, 2]
{1} [ 1,2] 2 [0,1]
{1,2} [0,1],[1,2] 3 cannot fit reject as
[0,1] is not free
{1,2} [0,1],[1,2] 4 assign to [2,3]
{1,2,4} [0,1],[1,2],[2,3] 5 reject

The optimal solution is {1,2,4}

35
A FASTER IMPLEMENTATION OF
JS (Contd..)
• As there are only n jobs and each job takes one unit of time,
it is necessary to consider the time slots [i-1,i] 1  i  b
where b = min {n, max {di}}
• The time slots are partitioned into b sets .
• i represents the time slot [i-1,i]
[0 1]is slot 1
[1 2] is slot 2
• For any slot i, ni represents the largest integers such that ni 
i and slot ni is free.
If [1,2] is free
n2=2 otherwise
n2=1 if [0 1] is free 36
A FASTER IMPLEMENTATION OF
JS (Contd..)
• To avoid end condition, we introduce a fictious
slot [-1, 0] which is always free.
• Two slots are in the same set iff ni= nj
• If i and j i < j are in the same set, then i, i+1, i+2,
…i are in the same set.
• Each set k of slots has a value f(k) ,f(k)=ni, for all
slots i in set k. (f(k) is the root of the tree
containing the set of slots k)
• Each set will be represented as a tree.
37
A FASTER IMPLEMENTATION OF
JS (Contd..)
• Initially all slots are free and f(i) = i 1  i  b.
• P(i) represents as a negative number the
number of nodes in the tree represented by the
set with slot I.
• P(i) = -1 0  i  b initially.
• If a job with deadline d is to be scheduled, we
find the root of the tree containing the slot min
{n, d}.
38
A FASTER IMPLEMENTATION OF
JS (Contd..)
EXAMPLE: For the problem n =5 (p1…p5) = (20,15,10,5,1),
(d1------d5) = (2,2,1,3,3) the trees defined by the P(i)’s are
J 1 2 3 4 5 Job considered
-1 -1 -1 -1 -1 -1 1,d1 = 2 [1,2] is free
φ P(0) P(1) P(2) P(3) P(4) P(5)
1 0 1 P(1) F(1)=0 2, d1 = 2
-2 F(1) = 1 [0,1] free
P(0) P(2) {1,2} -3 P(1)2 F[1] = 0 reject

0 0

39
A FASTER IMPLEMENTATION OF
JS (Contd..)
The algorithm for fast job scheduling (FJS) is as follows
Procedure FJS (D,n,b,j,k)
// Find an optimal solution J = J(1),…,J(k) 1  k  n //
// It is assumed that p1  p2  …..pn and b = min{n, max(d(i)) //
Integer b, D(n) ,J(n),F(O: b), P(O: b)
for i0 to b. Do // initialize trees //
F(i) i; P(i)-1
repeat
K 0 // Initialize J //
40
A FASTER IMPLEMENTATION OF
JS (Contd..)
For i 1 to n do // use greedy rules //
j  FIND (min (n, D(i)) // F(j) is the nearest free
slot if F(j) ≠ 0 //
if F(j) ≠ 0 then k k+1 ; J(k)i
All slots are not occupied
//select job i //
L  Find (F(j)-1); call union (L, j)
F(j)F(L) // j may be new root //
endif
repeat
end FJS
41
A FASTER IMPLEMENTATION OF
JS (Contd..)
It is F(j) –1 because you need to union J with I which
is F(j) -1.
F(i) is a value for a set of slots with l which is F(j)-1
F(k) = ni for all slots in the set k.
ni is that largest integer such that
ni  i and slot ni is free
F(1)=1 [0 1]
F(2)=2 [1 2]
P(i)= is the number of nodes in the tree respectively the
set with slot . 42
A FASTER IMPLEMENTATION OF
JS (Contd..)
Complexity of algorithm FJS
As there are n unions and 2n finds, in the for loop the
computing time is
0(n (2n , n))
 (m, n) m  n is related to Ackermal function
 (m,n)= min {z  1/A(3, 4[m/n]) > logn2}
For all practiced purposes, we may
assume log n < A(3,4) and hence
 (m,n)  3 m  n
The computing time of FJS is O(n)
Additional 2n words of space for F and P are required.
43