6212
Lecture {
}
CSCI 12
Design and Analysis of Algorithms
Hoeteck Wee [e-mail]
.
Second representative problem
weighted interval scheduling.
Input: set of jobs with start times, nish times and weights.
Find max weight subset of non-overlapping jobs
greedy works with earliest nish time rst if all weights are equal
(here, returns [12, 13, 16], not optimal)
1. use dynamic programming to nd opt := weight of max weight subset
2. use back-tracking to compute a subset with weight opt
.
Second representative problem
weighted interval scheduling.
Input: set of jobs with start times, nish times and weights.
Find max weight subset of non-overlapping jobs
1. use dynamic programming to nd opt := weight of max weight subset
need to break down opt into sub-problems
opt[i] := weight of max weight subset amongst jobs 1, 2, . . . , i
(sort jobs in order of increasing nish time)
answer corresponds to opt[n]
.
Weighted interval scheduling
1st goal. nd opt := weight of max-weight subset
opt[i] := weight of max weight subset amongst jobs 1, 2, . . . , i
opt(1) = 12
opt(2) = 20
opt(3) = 23
opt(4) = 25 = 12 + 13
opt(5) = 26
nd opt(6) recursively (using opt(1), . . . , opt(5))
choice : include vs exclude job 6 (weight 20)
choice #1 : exclude job 6
best is opt(5) = 26
choice #2: include job 6
overlaps with jobs 3, 4, 5
best is 20 + opt(2) = 40
.
Weighted interval scheduling
1st goal. nd opt := weight of max-weight subset
opt[i] := weight of max weight subset amongst jobs 1, 2, . . . , i
nd opt[i] recursively (using opt[1],...,opt[i-1])
choice : include vs exclude job i
choice #1 : exclude job i
best is opt[i-1]
choice #2 : include job i
nd largest s.t. j f[j] <= s[i] and set p[i] = j
best is w[i] + opt[j]
opt[i] = max(opt[i-1], w[i] + opt[j])
.
Weighted interval scheduling
1st goal. nd opt := weight of max-weight subset
opt[i] := weight of max weight subset amongst jobs 1, 2, . . . , i
opt[i] = max(opt[i-1], w[i] + opt[p[i]])
algorithm. dynamic programming
sort jobs by finish time
opt = [0] * (n+1)
p = [0] * (n+1)
for i in range(1,n+1):
find largest j s.t. f[j] <= s[i]
## using binary search
p[i] = j
opt[i] = max(opt[i-1], w[i] + opt[p[i]])
return opt[n]
running time. O(n log n)
2nd goal. nd subset whose weight is opt
remember each choice : include vs exclude job i
exclude job i : return the subset corresponding to opt[i-1]
include job i : return job i plus the subset corresponding to opt[p[i]]
.
Weighted interval scheduling
step 1. solving the sub-problems (to nd opt := weight of max-weight subset)
sort jobs by finish time
compute p[1], p[2], ..., p[n]
opt, include = [0] * (n+1), [False] * (n+1)
for i in range(1,n+1):
opt[i] = max(opt[i-1], w[i] + opt[p[i]])
include[i] = (w[i]+opt[p[i]] > opt[i-1])
step 2. back-tracking (to nd subset whose weight is opt)
ans, i = [], n
while i > 0:
if include[i]:
ans.append(i)
i = p[i]
else: i = i-1
return ans
.
General framework for dynamic programming
computing opt vs solution
opt := weight of max-weight subset
solution is subset whose weight is opt
use dynamic programming to nd opt
break opt down into sub-problems
opt corresponds to answer to some sub-problem
solve sub-problems bottom-up recursively (gure out the choices)
back-tracking to nd a solution
keep track of parent pointers (and best choices) for each sub-problem
.
the end
.