Special Topics on Algorithms Fall 2017 Dynamic Programming. Vangelis Markakis, Ioannis Milis and George Zois

Transcription

1 Special Topics on Algorithms Fall 2017 Dynamic Programming Vangelis Markakis, Ioannis Milis and George Zois

2 Basic Algorithmic Techniques Content Dynamic Programming Introduc<on Back to Fibonacci numbers Weighted Interval Scheduling Coin Changing Maximum Sub-array Edit Distance All-Pairs Shortest Paths

3 Richard Bellman (1953) Dynamic Programming Etymology (at that <me; Bellman was studying mul<-stage decision processes) Dynamic: rela<ng to <me Programming : what to do and when to do it Dynamic Programming: planning over <me Bellman gave an impressive name to be accepted by the Secretary of Defense (Wilson) who didn t like math research

4 Define sub-problems of the same structure with the original Overlapping sub-problems Op<mal substructure the op<mal solu<on includes/can be constructed from the op<mal solu<on to its sub-problems Solve the (sub)problem(s) star<ng from trivial ones write a recursive formula for the op<mal solu<on This gives an order of subproblems such that one can be solved given the answers of smaller ones (appearing earlier in this order) - A?en@on: We are not going to solve the problem via recursion Translate the recursive formula into an itera<ve algorithm Use a table to save intermediate results for later use Get the value of the op<mal solu<on Find the solu<on itself Dynamic Programming

5 Algorithm design methods DIVIDE AND CONQUER Non overlapping sub-problems Recursion can be used GREEDY A sub-problem defines the next one A single (greedy) choice DYNAMIC PROGRAMMING Overlapping sub-problems Recursion is forbidden Many choices for a sub-problem OPTIMAL SUB-STRUCTURE

6 Algorithm design methods DIVIDE AND CONQUER Non overlapping sub-problems Recursion can be used Tree GREEDY A sub-problem defines the next one A single (greedy) choice Chain DYNAMIC PROGRAMMING Overlapping sub-problems Recursion is forbidden Many choices for a sub-problem OPTIMAL SUB-STRUCTURE DAG

7 Fibonacci numbers Recall the Fibonacci sequence: F 0 = 0; F 1 = 1; F n = F n-1 + F n-2, n 2 Direct implementa<on of recursion: Algorithm fib1(n) // Direct implementa<on of recursion if n<2 then return n else return fib1(n-1)+ fib1(n-2)

8 Fibonacci numbers Recursion tree: 3 rd 2 nd st call 6 17 th 4 12 th 18 th rd Recursion? 5 th 1 4 th th 7 th 9 th 13 th 19 th 22 nd th th 10 th 11 th 14 th 15 th th th call th 21 st No, thanks! Τ(n) > 2 n/2

9 Fibonacci numbers Itera<ve version (non-recursive): Use a table to store intermediate values Algorithm fib2(n) //remember already computed values f[0]:=0; f[1]:=1; for i:=2 to n do f[i]:= f[i-1] + f[i-2] Note however: Time Complexity: O(n) NOT polynomial in I = O(logn) Space complexity: Also O(n) (but we could do it with 3 memory cells = O(1), as we saw before) Dynamic programming does not always yield polynomial <me algorithms

10 (Interval Scheduling) Suppose we want to schedule some jobs (e.g., courses) that need to use a common resource (e.g., a classroom) No 2 jobs can be scheduled at the same <me Interval Scheduling I: A set Α, of n jobs, each with a start <me s i and a finish <me f i Q: Find a feasible schedule with the maximum possible number of jobs (maximum throughput) Comment: There can be many op<mal solu<ons, scheduling different jobs each. We do not care here which op<mal solu<on we find For an instance I, we let OPT denote the op<mal schedule

11 (Interval Scheduling) OPT = 3

12 Some Algorithm Ideas ALG_1: Choose in each round the task that starts at the earliest possible feasible <me ALG_1=1, OPT=4 ALG_2: Choose in each round the shortest feasible task among the remaining ones. ALG_2=1, OPT=2 Other ideas?

13 Α greedy algorithm Rename the jobs so that f 1 f 2 f 3 f n Choose first the job with the earliest finish <me, f 1 Remove those that overlap with job 1 Con<nue in the same manner, choosing the earliest finish <me among the remaining ones Clearly a polynomial <me algorithm Proof of op@mality by induc@on or by contradic@on

14 Correctness How do we prove that a greedy algorithm is op<mal? Usually proof by contradic<on or by induc<on. But, the crucial property for a greedy algorithm to be op<mal, is that the problem should sa<sfy the op@mal substructure property. Op@mal substructure in general: A problem sa<sfies op#mal substructure if an op<mal solu<on to a problem contains within it op<mal solu<ons to subproblems. Op@mal Substructure for Ac@vity Selec@on: An op<mal solu<on (that contains the task with the earliest finishing <me), contains the op<mal solu<on for the tasks Α = { i Α : s i f 1 } (why?)

15 Correctness Theorem: Choosing in every round the job with the earliest finish <me produces an op<mal solu<on for the Ac<vity Selec<on problem.

16 Correctness Theorem: Choosing in every round the job with the earliest finish <me produces an op<mal solu<on for the Ac<vity Selec<on problem.

17 Weighted Interval Scheduling Weighted version: each job has a weight, may correspond to value or profit that we derive from the execu<on of each job Same constraints as before (no 2 jobs can be scheduled at the same <me) Weighted Interval Scheduling I: A set Α, of n jobs, each with a start <me s i, a finish <me f i, and a weight w i Q: Find a feasible schedule with the maximum possible total weight

18 Weighted Interval Scheduling The greedy algorithm we saw before does not work any more It may be beneficial to select just one job of high value than maximize the number of non-overlapping jobs Actually, no other greedy approach is known for this problem Dynamic Programming approach: We need to iden<fy if op<mal substructure occurs: A problem sa<sfies the op#mal substructure property if an op<mal solu<on to a problem contains within it op<mal solu<ons to subproblems Warmup: Reorder the jobs so that f 1 f 2 f 3 f n Let O j = op<mal schedule if we had only the jobs {1, 2,..., j} Let OPT(j) = total weight of the op<mal solu<on O j OPT( j) = w i O i j

19 Weighted Interval Scheduling Idea: try to find a recursive formula We need to relate OPT(j) with the op<mal values for smaller instances Defini<on: Let p(j) = largest index i, with i < j such that jobs i and j do not overlap i.e., the jobs p(j)+1, p(j)+2,...up to j-1 overlap with j Why is this useful? Consider an op<mal solu<on O j for {1, 2,..., j}. 2 observa<ons: If j is included in O j, then O j also contains an op<mal solu<on for {1, 2,..., p(j)} since there is no overlap with such jobs If j is not included in O j, then OPT(j) = OPT(j-1) Hence: OPT(j) = max{ w j + OPT(p(j)), OPT(j-1) }, for every j 1

20 Weighted Interval Scheduling This directly yields a recursive algorithm: Algorithm WIS1(n) // suppose we have pre-computed the values p(j) for every j if n=0 return 0; else return max(v n + WIS1(p(n)), WIS1(n-1)) To be more precise: The input to the algorithm consists of the vectors s = (s 1, s 2,..., s n ), the start <mes f = (f 1, f 2,..., f n ), the finish <mes (assume we have ordered them) w = (w 1, w 2,..., w n ), the weights WIS1(j) means the execu<on of the algorithm on the first j jobs Complexity: Recursion tree grows exponen<ally Same problem as with recursive algorithm for Fibonacci

21 Weighted Interval Scheduling Memoiza<on: Use an array to remember already computed values Loop through the array to compute the op<mal values to all subproblems Algorithm WIS2(n) Set M[0]=0; Compute the values p(j) for every j for j = 1 to n do M[j] = max(v j + M[p(j)], M[j-1]) return M[n] Complexity: Within each itera<on, we need only O(1) Hence O(n) total

22 Weighted Interval Scheduling The algorithm only computes the value of the op<mal solu<on What if we want to find the schedule as well We could use a different array S, so that S[i] maintains the op<mal solu<on up to {1,...,i} But this causes some blowup We can instead recover the solu<on from M (why?) Summarizing: Theorem: We can solve the Weighted Interval Scheduling problem in <me O(n) O(nlogn) if the finish <mes of the jobs are not sorted

23 Coin Changing Input: A value Ε and a set of n coins of values V={d 1, d 2, d 3,,d n } Question: Give the minimum number of coins to exchange the value E Note that: 1. We study inputs where the minimum value of a coin is 1 THEN there is always an optimal solution to the problem e.g., E = 13, V= {10, 6, 2 }, No solution! 2. Optimal Substructure : Let the optimal solution for value E using a coin of d i, then it must also contain the optimal solution for value E-d i 3. Greedy algorithm: Always choose the coin with the maximum possible value. Does not always gives the optimal solution: E = 40, V= {25, 20, 10, 5,1 }: E = , c=3, E = 2 20, OPT =2 OTHER IDEAS? DYNAMIC PROGRAMMING OPT = optimal

24 Coin Changing Sub-problem? c[j]: The minimum number of coins for value j c(e): The initial problem If the optimal solution for value j uses a coin of value d i, then c[j] = 1 + c[j d i ] obviously c[0]= 0 We check all the values in V={d 1, d 2, d 3,,d n } n We study inputs with minimum value equal to 1

25 Coin Changing Change(E,d[1..n]) c[0]=0 for j = 1 to E: c[j] = for i = 1 to n: if j d i and 1+c[j d i ] < c[j]: c[j] = 1+c[j d i ] return c Avoid examining c[j] for j<0 by ensuring that j d i Complexity: O(nΕ) Νοt O(poly)!

26 Coin Changing Example: E=10, {1,3,4} c[0] =0 c[1] =1+ min { c[1-1], c[1-3], c[1-4] } =1, c[2] =1+ min { c[2-1], c[2-3], c[2-4] } =2, c[3] =1+ min { c[3-1], c[3-3], c[3-4] } =1, c[4] =1+ min { c[4-1], c[4-3], c[4-4] } =1, c[5] =1+ min { c[5-1], c[5-3], c[5-4] } =2, c[6] =1+ min { c[6-1], c[6-3], c[6-4] } =2, c[7] =1+ min { c[7-1], c[7-3], c[7-4] } =2, c[8] =1+ min { c[8-1], c[8-3], c[8-4] } =2, c[9] =1+ min { c[9-1], c[9-3], c[9-4] } =3, denom[1]=1 denom[2]=1 denom[3]=3 denom[4]=4 denom[5]=1 denom[6]=3 denom[7]=3 denom[8]=4 denom[9]=1 c[10]=1+ min { c[10-1], c[10-3], c[10-4] } =3, denom[10]=3

27 Coin Changing Which Coins? denom[1..n]: The value of the coin that gave the optimal solution for value j Change(E,d[1..n]) c[0]=0 for j = 1 to E: c[j] = for i = 1 to n: if j d i and 1+c[j d i ] < c[j]: Complexity: (ne) c[j] = 1+c[j d i ] denom[j]=d i j=e while j>0: write denom[j] j= j-denom[j] Not O(poly I )!

28 Maximum Sub-array (MSA) Maximum Sub-Array (MSA): I: Array of numbers Α[1..n] Q: Find a sub-array Α[p..q] with a maximum sum of its elements Hence, we are looking for indices p, q, so that the sub-array A[p..q] maximizes the quantity Example: Profit history V(p, q) = A(i) i=p q Year Profit We want the period of years with the greatest profit: V(5,8)=9

29 MCS: Dynamic Programming Maximum Sub-array (MSA) We need to find a recurrence Let E(i) be the value of the maximum sequence ending in posi<on i Observa<on: The MSA is one of the E(i) s, that is Vmax = max i { E(i) } The problem is then reduced to the calcula<on of the E(i) s DP: Find the E(i) based on E(i-1) (exploit op<mal substructure) E(i) has to contain A(i) Two cases for E(i): Either it contains only A[i]: E(i) = A[i] Or it contains the op<mal solu<on E(i-1): E(i) = E(i-1) + A[i] Hence: E(i) = max { E(i-1)+A[i], A[i] } E(1)=A[1]

30 Maximum Sub-array (MSA) Example: E(i) = max { E(i-1)+A[i], A[i] }, E(1)=A[1] A[1..n] Maximum Sum for any sub Array ending at i th location E[1..n] Vmax Maximum so far

31 Maximum Sub-array (MSA) E(i) = max { E(i-1)+A[i], A[i] }, E(1)=A[1] MSA(A[1..n]) E(1)=A[1], Vmax=A(1) for i = 2 to n do E(i) = E(i-1)+A(i) if E(i) < A(i) then E(i) = A(i) if E(i) > Vmax then Vmax = E(i) Time complexity: O(n) Space Complexity: O(n) (for the array E) O(1) if we remove the indices

32 Maximum Sub-array (MSA) What about the indices p, q of the op<mal solu<on? Let P(i) be the start index of E(i) MSA(A[1..n]) E(1)=A[1], Vmax=A(1), P(i)=1 For i = 2 to n do E(i) = E(i-1)+A(i), P(i)=P(i-1) if E(i) < A(i) E(i) = A(i) P(i) = i if E(i) > Vmax Vmax = E(i) p=p(i) q=i Time complexity: O(n) Space Complexity: O(n) (for arrays E, P), O(1) if we remove the indices

33 Edit distance Edit distance between two strings = the minimum number of edits insertions deletions substitutions to transform the first string into the second Alignment: writing the strings one above the other using spaces (-) # of edits = # of columns in which the characters of the strings differ Edit distance: the minimum cost over all possible alignments

34 Edit distance Example # of edits=3 # of edits=5 insert U insert S substitute O with N substitute S with U delete W delete O delete W insert N Too many possible alignments between two strings! How can we find the best alignment?

35 Edit distance Dynamic Programming Strings X[1..m] and Y[1..n] X[1..i], i m-1 is a prefix of X Y[1..i], i n-1 is a prefix of Y Subproblem: E[i,j]) = Minimum Edit Distance between X[1..i] and Y[1..j] Optimal substructure: Consider the rightmost column of an optimal alignment In each of the cases (i) to (iv) below the Edit Distance of the involved prefixes must be minimum: (i) Match: E(i,j)= E(i-1,j-1) (ii) Substitute: E(i,j)= E(i-1,j-1) +1 (iii) Insert: E(i,j)= E(i-1,j)+1 (iv) Delete: E(i,j)= E(i,j-1) +1 Edit distance between X and Y = E[m,n] First we ll find the Edit distance, then the edits themselves

36 Edit distance Three choices for the rightmost column of an alignment: 1 + E(i-1, j) 1+ E(i, j-1) diff(i, j) + E(i-1, j-1) where 1 if x[i] y[j] diff = 0 if x[i] = y[j] Base cases: E(0,j) = j : alignment of empty string and Y[1..j] E(i,0) = i : alignment of X[1..i] and empty string

37 Edit distance The subproblem E(7, 5), diff =0 N or - or N - N N E(7,5) = min {1+ E(6,5), 1+ E(7,4), 0+E(6,4) }

38 Edit distance Fill a two-dimensional array by solving subproblems Row by row or column by column match or subst delete insert x x x x x x = 6 edits

39 Edit distance Complexity? Extent the algorithm to find the actual edits

40 Shortest paths in DAGs Dag G=(V,E) Topological sorting of G We know that there are no nega<ve weight cycles in such graphs We apply a dynamic programming approach aler we find a topological sor<ng of the ver<ces Define the op<mal substructure and a recursive formula? d( u) = min v Γ ( u) { w( v, u) + d( v)}, d(s) = 0

41 Shortest paths in DAGs d( u) = min v Γ ( u) { w( v, u) + d( v)}, d(s) = 0 for each u V do { d(u}:= ; pred(u):= null } d(s):=0; Find a topological sorting of G for each u V {s} in topological order do {for each v Γ - (u) do if w(v,u)+d(v) < d(u) then { d(u):= w(v,u)+d(v) ; pred(u):= v; } } Complexity? Nega@ve weights? O(n+m) No problem!

42 All pairs shortest paths All-pairs shortest paths I: A weighted graph G = (V, E, w) Q: A shortest path for every pair of nodes Run Bellman-Ford n <mes O(n 2 m) Can we do bezer? First, we extend the weight func<on to all pairs: w( u, v) = 0 w( e) if if if u u u = v v v and and e e = = ( u, v) ( u, v) E E

43 All pairs shortest paths We will again use a dynamic programming approach but a different one from before Suppose we name the ver<ces as 1, 2,..., n d(u, v, k):= shortest path from node u to node v using only nodes {1,2,, k} as intermediates u d(u,v,k-1) o o v d(u,k,k-1) o k d(k,v,k-1) d( u, v,0) = w( u, v) d( u, v, k) = min{ d( u, v, k 1), d( u, k, k 1) + d( k, v, k 1)}

44 All pairs shortest paths d( u, v,0) = w( u, v) d( u, v, k) = min{ d( u, v, k 1), d( u, k, k 1) + d( k, v, k 1)} We will gradually find d(u,v,0), d(u,v,1), d(u,v,2),, d(u,v,n) for all u, v Idea of the algorithm implementa@on: Use d(u, v) as the current es<mate, ini<ally set to w(u, v) Think of it as filling up a n x n array for each k Itera<on 1: update d(u, v) to equal the shortest path length using node 1 as intermediate... Itera<on k: update d(u, v) to equal the shortest u-v path with {1, 2,...,k} as intermediates Con<nue un<l itera<on n d(u, v) = min{d(u, v), d(u, k)+ d(k, v)}

45 All pairs shortest paths Algorithm Floyd-Warshall(G) for u:=1 to n do for v:=1 to n do { d(u,v):= w(u,v); pred(u,v):= null } for k:=1 to n-1 do for u:=1 to n do for v:=1 to n do if d(u,k) + d(k,v) < d(u,v) then { d(u,v):= d(u,k) + d(k,v); pred(u,v):= k } pred(u,v): to be used for extrac<ng the u-v shortest path Complexity: O(n 3 )

46 All pairs shortest paths

47 All pairs shortest paths Extract the u-v shortest path Path (u,v); { if pred(u,v)=null then output (u,v) else {Path(u,pred(u,v)), Path(pred(u,v),v) } }