programminghomeworkhelp.com_Advanced Algorithms Homework Help.pptx

For any Homework related queries, Call us at : - +1 678 648 4277
You can mail us at : - support@programminghomeworkhelp.com or
reach us at : - https://www.programminghomeworkhelp.com/

Problem 1. Oil Well that Ends Well The oil wells of tycoon Ron Jockefeller will produce m
oil barrels this month. Ron has a list of n orders from potential buyers, where the ith order
states a willingness to buy ai barrels for a total price of pi (not per barrel), which may be
negative.1 Each order must be filled completely or not at all, and can only be filled once.
Ron does not have to sell all of his oil, but he must pay s dollars per unsold barrel in
storage costs. Describe an O(nm)-time algorithm to determine which orders to fill so that
Ron can maximize his profit (which may be negative).
Solution:
1. Subproblems
• x(i, j) : maximum possible profit by selling j barrels to the suffix of buyers i through
n
• for i ∈ {1,...,n + 1},j ∈ {0,...,m}
2. Relate
• Ron can either sell or not sell to buyer i
– If he sells, can’t sell to them again but must sell remaining barrels
– If not sells, no change to barrels to be sold
• x(i, j) = max x
3. Topo. Order
• x(i, j) only depends on subproblems with strictly larger i, so acyclic
programminghomeworkhelp.com

4. Base
• If no more buyers remain, Ron must pay s dollars per unsold barrel
• x(n +1,j) = −sj for all j ∈ {0,...,m}
5. Original
• Solve subproblems via recursive top down or iterative bottom up
• x(1,m) is the maximum profit allowing sales of m barrels to all buyers
• Store parent pointers to reconstruct which sales fulfill an optimal order
6. Time
• # subproblems: (n + 1)(m + 1) = O(nm)
• Work per subproblem: O(1)
• O(nm) running time, which is pseudopolynomial in the size of the input
Rubric: (Same for all problems in PS7)
• S: 5 points for a correct subproblem description
• R: 5 points for a correct recursive relation
• T: 2 points for indication that relation is acyclic
• B: 2 point for correct base cases in terms of subproblems
• O: 2 point for correct original solution in terms of subproblems
• T: 2 points for correct analysis of running time
• 4 points if a correct dynamic program is efficient (meets requested bound)
• 3 points for correctly labeling running time polynomial or pseudopolynomial
• Partial credit may be awarde

Problem 2. Splits Bowling
In Lecture 15, we introduced Bowling: a one-player game played on a sequence of n pins,
where pin i has integer value vi (possibly negative). The player repeatedly knocks down
pins in two ways:
• knock down a single pin, providing vi points; or
• knock down two adjacent pins i and i + 1, providing vi · vi+1 points.
Pins may be knocked down at most once, though the player may choose not to knock down
some pins. A Bowling variant, Split Bowling, adds a third way the player can knock down
two pins forming a split, specifically:
• knock down two pins i and j > i + 1 if all pins in {i + 1,...,j − 1} between them have
already been previously knocked down, providing vi · vj points.
Describe an O(n3)-time algorithm to determine the maximum score possible playing Split
Bowling on a given input sequence of n pins.
Solution:
1. Subproblems
• Assume pins are zero-indexed in array V = (v0,...,vn−1)
• x(i, j, c) : maximum possible score playing Split Bowling on substring of pins V [i :
j], where all pins in range must be knocked down if c = 1, but unconstrained if c =
0
• for i ∈ {0,...,n},j ∈ {i,... , n},c ∈ {0, 1}

2. Relate
• Guess what to do with pin i
– If c = 0, can choose not to knock down pin i
– Otherwise, can knock down pin i in one of three ways:
∗ knock down by itself getting vi points,
∗ knock down with pin i + 1 for vi · vi+1 points, or
∗ knock down with pin k for vi · vk points for some k ∈ {i + 2,...,j − 1}
– In last case, need max value to knock down all pins between and pins after
3. Topo. Order
• x(i, j) only depends on subproblems with strictly smaller j − i, so acyclic
4. Base
• x(i, i, k) = 0 (no more pins gives zero value)
• for i ∈ {0,...,n},k ∈ {0, 1}
5. Original
• x(0, n, 0) : maximum score possible playing on all pins, unconstrained
6. Time
• # subproblems: O(n2)
• Work per subproblem: O(n)

• O(n3) running time, which is polynomial in the size of the input
Problem 3. Quarter Partition
Given a set A = {a0,...,an−1} containing n distinct positive integers where m =
describe an O(m3n)-time algorithm to return a partition of A into four subsets A1,
A2, A3, A4 ( A (where A1 ∪ A2 ∪ A3 ∪ A4 = A) such that the maximum of their
individual sums is as small as ai∈A possible, i.e., such that max { ΣaiεAj ai| j ϵ {
1,2,3,4}}is minimized.
Solution:
1. Subproblems,
• x(k, s1,s2,s3) : True if it is possible to partition suffix of items A[k :] into four
subsets A1,A2,A3,A4, where sj = P ai∈Aj ai for all j ∈ {1, 2, 3}, and false
otherwise
• for k ∈ {0,...,n} and s1,s2,s3 ∈ {0,...,m}
2. Relate
• Integer ak must be placed in some partition. Guess!
• x(k, s1,s2,s3) = OR

3. Topo. Order
• x(k, s1,s2,s3) only depends on subproblems with strictly larger k, so acyclic
4. Base
• x(n, 0, 0, 0) = True (can partition zero integers into zero sum subsets)
• x(n, s1,s2,s3) = False for any s1,s2,s3 > 0
• (cannot partition zero integers into any subset with positive sum)
• for i ∈ {0,...,n},k ∈ {0, 1}
5. Original
• Let m(0,s1,s2,s3) =
• Solution to original problem is then given by:
• min{m(0,s1,s2,s3) | s1,s2,s3 ∈ {0,...,m}}
• Store parent pointers to reconstruct each subset
6. Time
• # subproblems: O(m3n)
• Work per subproblem: O(1) any maximal

• Work to compute original: O(m3)
• O(m3n) running time, which is pseudopolynomial in the size of the input
Problem 4. Corrupt Chronicles
Kimmy Jerk is the captain of the USS Exitcost, a starship charged with exploring new
worlds. Each day, Capt. Jerk uploads a captain’s log to the ship’s computer: a string of at
most m lowercase English letters and spaces, where a word in a log is substring not
containing a space. One day, Capt. Jerk is abducted, and Communications Officer Uhota
Nyura goes to the captain’s logs looking for evidence. Unfortunately, the log upload
system has malfunctioned, and has corrupted each of the last n logs by dropping all
spaces. Officer Nyura wants to restore the spaces based on Capt. Jerk’s speech patterns in
previous logs. Given a list Lc of the n corrupted logs, as well as a list Lu of O(m2n)
uncorrupted logs from before the malfunction, Officer Nyura wants to:
• for each word w appearing in any log in Lu, compute f(w): the positive integer number
of times word w appears in Lu (note, f(w) is zero for any word w not appearing in Lu);
and
• for each log ` i ∈ Lc, return a restoration Ri of ` i (i.e, a sequence of words Ri whose
ordered concatenation equals ` i), such that P w∈Ri f(w) is maximized over all possible
restorations.
Describe an O(m3n)-time algorithm to restore Capt. Jerk’s logs based on the above
protocol.

Solution: Observe that if we can process Lu in O(m2n) time, and then compute the
restoration the n corrupted logs, each in O(m3) time, then we will be within the desired
bound.
First, scan through each of the O(m2n) at most length-m uncorrupted logs, and insert each
word w into a hash table H mapping to frequency f(w). Specifically, if w does not appear
in H, add it to H mapping to 1, and if w does appear in H, increase the mapped value by 1.
This process computes all f(w) for words appearing in any log in Lu directly in expected
O(m3n) time, since the time to hash each word is linear in its length. Second, we compute
a restoration for each log ` i in Lc via dynamic programming in expected O(m3) time,
leading to an expected O(m3n) running time in total, which is polynomial in the size of the
input (there are at least Ω(nm) characters in the input).
1. Subproblems
• x(j) : maximum P w∈Ri,j f(w) for any restoration Ri,j of suffix ` i[j :]
• for j ∈ {0,..., |` i| ≤ m}
2. Relate
• Guess the first word in ` i[j :] and recurse on the remainder
• x(j) = max{f(` i[j : k]) + x(k) | k ∈ {j +1,..., |` i|}} H(w) if w ∈ H
• Where f(w) = 0
3. Topo. Order
• x(j) only depends on strictly larger j, so acyclic

4. Base
• x(|` i|) = 0 (no log left to restore)
5. Original
• Solution to original problem is given by x(0)
• Store parent pointers to reconstruct a restoration achieving value x(0)
6. Time
• # subproblems: O(m)
• Work per subproblem: O(m2)
• (O(m) choices, and each hash table lookup costs expected O(m) time)
• Expected O(m3) running time per restoration

programminghomeworkhelp.com_Advanced Algorithms Homework Help.pptx

More Related Content

Similar to programminghomeworkhelp.com_Advanced Algorithms Homework Help.pptx

More from Programming Homework Help

Recently uploaded

programminghomeworkhelp.com_Advanced Algorithms Homework Help.pptx