CS583 Lecture 10. Graph Algorithms Shortest Path Algorithms Dynamic Programming. Many slides here are based on D. Luebke slides.

Transcription

1 // S58 Lecture Jana Kosecka Graph lgorithms Shortest Path lgorithms Dynamic Programming Many slides here are based on D. Luebke slides Previously Depth first search DG s - topological sort - strongly connected components MST - Prim s - Kruskal s Shortest path with non-negative weights

2 // Shortest Path lgorithms Single-Source Shortest Path Problem: given a weighted directed graph G, find the minimum-weight path from a given source vertex s to another vertex v Shortest-path = minimum weight Weight of path is sum of edges E.g., a road map: what is the shortest path from Faixfax to Washington D?

3 // Shortest Path Properties gain, we have optimal substructure: the shortest path consists of shortest subpaths: Proof: suppose some subpath is not a shortest path There must then exist a shorter subpath ould substitute the shorter subpath for a shorter path but then overall path is not shortest path. ontradiction Optimal substructure property hallmark of dynamic programming Shortest Path Properties In graphs with negative weight cycles, some shortest paths will not exist (Why?): <

4 // Relaxation key technique in shortest path algorithms is relaxation Idea: for all v, maintain upper bound d[v] on δ(s,v) Relax(u,v,w) { if (d[v] > d[u]+w) then d[v]=d[u]+w; } Relaxing an edge checking if it can improve The cost of the path Relax Relax Shortest Path Properties Define δ(u,v) to be the weight of the shortest path from u to v Shortest paths satisfy the triangle inequality: δ(u,v) δ(u,x) + δ(x,v) Proof : x u v This path is no longer than any other path

5 // Shortest Path Properties Triangle inequality Upper bound property No path property onvergence Property Path relaxation property Predecessor subgraph property Dijkstra s lgorithm If no negative edge weights, we can beat ellman-ford Similar to breadth-first search Grow a tree gradually, advancing from vertices taken from a queue lso similar to Prim s algorithm for MST Use a priority queue keyed on d[v] 5

6 // ellman Ford lgorithm Single source shortest path algorithm Weights can be negative lgorithm returns NIL if there is negative weight cycle Otherwise returns produces shortest paths from source to all other vertices ellman-ford lgorithm ellmanford() for each v V d[v] = ; d[s] = ; for i= to V - for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return no solution ; Initialize d[], which will converge to shortest-path value δ Relaxation: Make V - passes, relaxing each edge Test for solution Under what condition do we get a solution? Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w 6

7 // ellman-ford lgorithm ellmanford() for each v V d[v] = ; d[s] = ; for i= to V - for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return no solution ; What will be the running time? Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w ellman-ford lgorithm ellmanford() for each v V d[v] = ; d[s] = ; for i= to V - for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return no solution ; What will be the running time? : O(VE) Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w 7

8 // ellman-ford lgorithm ellmanford() for each v V s d[v] = ; d[s] = ; for i= to V - for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return no solution ; - E - D 5 Ex: work on board Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w ellman-ford Running time O(VE) Not so good for large dense graphs Still very practical 8

9 // ellman-ford Prove: lgorithm after V - passes of the for loop, all d values (shortest path values) are correct (for all vertices) onsider shortest path from s to v, since the path is simple (no loops) there are at most V - edges s v v v v v Initially, d[s] = is correct, and doesn t change (Why?) fter pass through edges, d[v ] is correct (Why?) and doesn t change fter passes, d[v ] is correct and doesn t change Terminates in V - passes: (Why?) What if it doesn t? ellman-ford Note that order in which edges are processed affects how quickly it converges orrectness: show d[v] = δ(s,v) for all vertices or returns FLSE (negative weight cycle) y previous lemma at the termination we have d[v] = δ(s,v) <= δ(s,u) + w(u,v) by triangle inequality = d[u] + w(u,v) nd none of the test in the last loop will return no solution, i.e. TRUE. if (d[v] > d[u] + w(u,v)) return no solution ; If there is a negative weight cycle prove by contradiction that ellman Ford algorithm will return FLSE (see book) 9

10 // DG Shortest Paths Problem: finding shortest paths in DG ellman-ford takes O(VE) time. How can we do better? Idea: use topological sort If were lucky and process vertices on each shortest path from left to right, would be done in one pass Every path in a DG is subsequence of topologically sorted vertex order, so processing vertices in that order, we will do each path in forward order (will never relax edges out of vertex before doing all edges into vertex). Thus: just one pass. What will be the running time? Review: Dijkstra s lgorithm Dijkstra(G) for each v V d[v] = ; d[s] = ; S = ; Q = V; 5 while (Q ) u = ExtractMin(Q); S = S U {u}; for each v u->dj[] if (d[v] > d[u]+w(u,v)) d[v] = d[u]+w(u,v); Note: this is really a call to Q->DecreaseKey() Ex: run the algorithm D Relaxation Step

11 // orrectness Of Dijkstra's lgorithm s p x y p u. See the description of the proof in the book Show that Dijkstra s algorithm will terminate with The cost of each node to be the cost of shortest path. Idea: show that when the vertex is added to the set the cost of that vertex is the length of the shortest path Reminder: We always add the vertex with minimal cost orrectness Of Dijkstra's lgorithm s p x y p u Want to show that when vertex is added to set S, d[u] = δ(s,u) and throughout note that d[u] δ(s,u) u Proof by contradiction d[u] is not equal to δ(s,u) efore u gets added, some other vertex y on that shortest path needs to be added; claim that d[y] = δ(s,y) when added. Know that d[x] = δ(s,x) and δ(s,y) <= δ(s,u) and d[y] = δ(s,y), so d[y] <= d[u] ut both y and u are outside of S when is chosen so d[u] <= d[y] Hence d[y] = d[u] = δ(s,y) = δ(s,y)

12 // Previously Shortest path algorithms: given single source compute shortest path to all other vertices. Dijkstra O( E + V lg V) ellman-ford O(VE) DG O(V+E) ll pairs shortest path: compute shortest path between each pair of nodes Option. Run single source shortest path from each node using previous algorithms Run ellman-ford once for each vertex O(V E) an we do better? See ll-pairs-shortest path Dynamic Programming hap 5.

13 // Dynamic Programming nother strategy for designing algorithms is dynamic programming metatechnique, not an algorithm (like divide & conquer) The word programming is historical and predates computer programming Use when problem breaks down into recurring small subproblems Dynamic Programming History ellman. Pioneered the systematic study of dynamic programming in the 95s. Etymology. Dynamic programming = planning over time. Secretary of Defense was hostile to mathematical research. ellman sought an impressive name to avoid confrontation. "it's impossible to use dynamic in a pejorative sense" "something not even a ongressman could object to" Reference: ellman, R. E. Eye of the Hurricane, n utobiography.

14 // Dynamic Programming pplications reas. ioinformatics. ontrol theory. Information theory. Operations research. omputer science: theory, graphics, I, systems,. Some famous dynamic programming algorithms. Viterbi for hidden Markov models. Unix diff for comparing two files. Smith-Waterman for sequence alignment. ellman-ford for shortest path routing in networks. ocke-kasami-younger for parsing context free grammars. More Examples Dynamic Programming Matrix chain multiplication Longest common subsequence Optimal triangulation ll-pairs-shortest path

15 // Dynamic Programming Problem solving methodology (as divide and conquer) Idea: divide into sub-problems, solve sub-problems pplicable to optimization problems Ingredients. haracterize the optimal solution. Recursively define a value of the optimal solution. ompute values of optimal solution bottom up. onstruct an optimal solution from computed inf. Dynamic programming It is used, when the solution can be recursively described in terms of solutions to sub-problems (optimal substructure) lgorithm finds solutions to sub-problems and stores them in memory for later use More efficient than brute-force methods, which solve the same sub-problems over and over again 5

16 // Weighted Interval Scheduling Weighted Interval Scheduling Weighted interval scheduling problem. Job j starts at s j, finishes at f j, and has weight or value v j. Two jobs compatible if they don't overlap. Goal: find maximum weight subset of mutually compatible jobs. a b c d e f g h Time 6

17 // Unweighted Interval Scheduling Review Observation. Greedy algorithm can fail spectacularly if arbitrary weights are allowed. weight = 999 weight = a b Time Weighted Interval Scheduling Notation. Label jobs by finishing time: f f... f n. Def. p(j) = largest index i < j such that job i is compatible with j. Ex: p(8) = 5, p(7) =, p() = Time 7

18 // Dynamic Programming: inary hoice Notation. OPT(j) = value of optimal solution to the problem consisting of job requests,,..., j. optimal substructure ase : OPT selects job j. can't use incompatible jobs { p(j) +, p(j) +,..., j - } must include optimal solution to problem consisting of remaining compatible jobs,,..., p(j) ase : OPT does not select job j. must include optimal solution to problem consisting of remaining compatible jobs,,..., j- # if j = OPT( j) = $ % max v j + OPT( p( j)), OPT( j ) { } otherwise Weighted Interval Scheduling: rute Force rute force recursive implemenation Input: n, s,,s n, f,,f n, v,,v n Sort jobs by finish times so that f f... f n. ompute p(), p(),, p(n) ompute-opt(j) { if (j = ) return else return max(v j + ompute-opt(p(j)), ompute- Opt(j-)) } 8

19 // Weighted Interval Scheduling: rute Force Observation. Recursive algorithm fails spectacularly because of redundant sub-problems exponential algorithms. Ex. Number of recursive calls for family of "layered" instances grows like Fibonacci sequence. 5 5 p() =, p(j) = j- Weighted Interval Scheduling: Memoization Memoization. Store results of each sub-problem in a cache; lookup as needed. Input: n, s,,s n, f,,f n, v,,v n Sort jobs by finish times so that f f... f n. ompute p(), p(),, p(n) for j = to n M[j] = empty M[j] = global array M-ompute-Opt(j) { if (M[j] is empty) M[j] = max(w j + M-ompute-Opt(p(j)), M-ompute- Opt(j-)) return M[j] } 9

20 // Weighted Interval Scheduling: Running Time laim. Memoized version of algorithm takes O(n log n) time. Sort by finish time: O(n log n). omputing p( ) : O(n) after sorting by start time. M-ompute-Opt(j): each invocation takes O() time and either (i) returns an existing value M[j] (ii) fills in one new entry M[j] and makes two recursive calls Progress measure Φ = # nonempty entries of M[]. initially Φ =, throughout Φ n. (ii) increases Φ by at most n recursive calls. Overall running time of M-ompute-Opt(n) is O(n). Remark. O(n) if jobs are pre-sorted by start and finish times. Weighted Interval Scheduling: Finding a Solution Q. Dynamic programming algorithms computes optimal value. What if we want the solution itself?. Do some post-processing. Run M-ompute-Opt(n) Run Find-Solution(n) Find-Solution(j) { if (j = ) output nothing else if (v j + M[p(j)] > M[j-]) print j Find-Solution(p(j)) else Find-Solution(j-) }

21 // Weighted Interval Scheduling: ottom-up ottom-up dynamic programming. Unwind recursion. Input: n, s,,s n, f,,f n, v,,v n Sort jobs by finish times so that f f... f n. ompute p(), p(),, p(n) Iterative-ompute-Opt { M[] = for j = to n M[j] = max(v j + M[p(j)], M[j-]) } Dynamic Programming Example: Longest ommon Subsequence Longest common subsequence (LS) problem: Given two sequences x[..m] and y[..n], find the longest subsequence which occurs in both Ex: x = { D }, y = { D } { } and { } are both subsequences of both What is the LS? rute-force algorithm: For every subsequence of x, check if it s a subsequence of y How many subsequences of x are there? What will be the running time of the brute-force alg?

22 // Longest ommon Subsequence (LS) pplication: comparison of two DN strings Ex: X= { D }, Y= { D } Longest ommon Subsequence: X = D Y = D rute force algorithm would compare each subsequence of X with the symbols in Y LS lgorithm rute-force algorithm: m subsequences of x to check against n elements of y: O(n m ) We can do better: for now, let s only worry about the problem of finding the length of LS When finished we will see how to backtrack from this solution back to the actual LS Notice LS problem has optimal substructure Subproblems: LS of pairs of prefixes of x and y

23 // LS lgorithm First we ll find the length of LS. Later we ll modify the algorithm to find LS itself. Define X i, Y j to be the prefixes of X and Y of length i and j respectively Define c[i,j] to be the length of LS of X i and Y j Then the length of LS of X and Y will be c[m,n] c[ i, c[ i, j ] + j] = max( c[ i, j ], c[ i, j]) if x[ i] = y[ j], otherwise c[ i, LS recursive solution c[ i, j ] + j] = max( c[ i, j ], c[ i, if x[ i] = j]) otherwise y[ j], We start with i = j = (empty substrings of x and y) Since X and Y are empty strings, their LS is always empty (i.e. c[,] = ) LS of empty string and any other string is empty, so for every i and j: c[, j] = c[i,] =

24 // c[ i, LS recursive solution c[ i, j ] + j] = max( c[ i, j ], c[ i, if x[ i] = j]) otherwise y[ j], When we calculate c[i,j], we consider two cases: First case: x[i]=y[j]: one more symbol in strings X and Y matches, so the length of LS X i and Y j equals to the length of LS of smaller strings X i- and Y i-, plus LS recursive solution c[ i, j ] + c[ i, j] = max( c[ i, j ], c[ i, if x[ i] = j]) otherwise y[ j], Second case: x[i]!= y[j] s symbols don t match, our solution is not improved, and the length of LS(X i, Y j ) is the same as before (i.e. maximum of LS(X i, Y j- ) and LS(X i-,y j ) Why not just take the length of LS(X i-, Y j- )?

25 // LS Length lgorithm LS-Length(X, Y). m = length(x) // get the # of symbols in X. n = length(y) // get the # of symbols in Y. for i = to m c[i,] = // special case: Y. for j = to n c[,j] = // special case: X 5. for i = to m // for all X i 6. for j = to n // for all Y j 7. if ( X i == Y j ) 8. c[i,j] = c[i-,j-] + 9. else c[i,j] = max( c[i-,j], c[i,j-] ). return c LS Example We ll see how LS algorithm works on the following example: X = Y = D What is the Longest ommon Subsequence of X and Y? LS(X, Y) = X = Y = D 5

26 // i LS Example () j 5 Yj D Xi D X = ; m = X = Y = D; n = Y = 5 llocate array c[5,] i LS Example () j 5 Yj D D Xi for i = to m c[i,] = for j = to n c[,j] = 6

27 // i LS Example () j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) i LS Example () j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) 7

28 // i LS Example () j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) i LS Example (5) j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) 8

29 // i LS Example (6) j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) i LS Example (7) j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) 9

30 // i LS Example (8) j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) i LS Example () j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] )

31 // i LS Example () j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) i LS Example () j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] )

32 // i LS Example () j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) LS Example () D i j 5 Yj D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] )

33 // i LS Example (5) j 5 Yj D D Xi if ( X i == Y j ) c[i,j] = c[i-,j-] + else c[i,j] = max( c[i-,j], c[i,j-] ) LS lgorithm Running Time LS algorithm calculates the values of each entry of the array c[m,n] So what is the running time? O(m*n) since each c[i,j] is calculated in constant time, and there are m*n elements in the array

34 // How to find actual LS So far, we have just found the length of LS, but not LS itself. We want to modify this algorithm to make it output Longest ommon Subsequence of X and Y Each c[i,j] depends on c[i-,j] and c[i,j-] or c[i-, j-] For each c[i,j] we can say how it was acquired: For example, here c[i,j] = c[i-,j-] + = += How to find actual LS - continued Remember that c[ i, j ] + c[ i, j] = max( c[ i, j ], c[ i, j]) So we can start from c[m,n] and go backwards Whenever c[i,j] = c[i-, j-]+, remember x[i] (because x[i] is a part of LS) if x[ i] = otherwise When i= or j= (i.e. we reached the beginning), output remembered letters in reverse order y[ j],

35 // i Finding LS j 5 Yj D Xi i Finding LS () j 5 Yj D Xi LS (reversed order): LS (straight order): 5

36 // Review: Dynamic Programming Summary of the basic idea: Optimal substructure: optimal solution to problem consists of optimal solutions to subproblems Overlapping subproblems: few subproblems in total, many recurring instances of each Solve bottom-up, building a table of solved subproblems that are used to solve larger ones Variations: Table could be -dimensional, triangular, a tree, etc. omputer Vision: Energy minimization: dynamic programming v v v v v 5 v 6 With this form of the energy function, we can minimize using dynamic programming, with the Viterbi algorithm. Iterate until optimal position for each point is the center of the box, i.e., the snake is optimal in the local search space constrained by boxes. Fig from Y. oykov [mini, Weymouth, Jain, 99] 6

37 // Energy minimization: dynamic programming Possible because snake energy can be rewritten as a sum of pair-wise interaction potentials: n E total (ν,,ν n ) = E i (ν i,ν i+ ) i= Or sum of triple-interaction potentials. n E total (ν,,ν n ) = E i (ν i,ν i,ν i+ ) i= Viterbi algorithm Main idea: determine optimal position (state) of predecessor, for each possible position of self. Then backtrack from best state for last vertex. E total = E (v,v ) + E (v,v ) E n (v n,v n ) states m vertices E (v,v ) E (v,v ) E (v,v ) v v v v E () = E () = E () = E (m) = E ( m) E ( ) E ( ) m m E (v,v n ) E () E () E () E n () E () E () E () E n () E () E () E () E n () v n E n (m) omplexity: O(nm ) vs. brute force search? Example adapted from Y. oykov 7

38 // Viterbi alg. dynamic programming We are interested in the assignment of states for vertices, v,v,...v n such that total energy is minimized. Each vertex can be in one of the m states s,s,...s m min vn min vn... min v = [E (v,v ) + E (v,v ) E n (v n,v n )] min vn min vn = [E n (v n,v n ) E (v,v ) + min v E (v,v )] min vn min vn = [E n (v n,v n ) E (v,v ) + M, (v )].. min vn = [E n (v n,v n ) + M n,n (x n )] memoize the partial solution Matrix hain Multiplication Given sequence of matrices n nd their dimensions p, p, p, p n What is the optimal order of multiplication Example: why two different orders matter? rute force strategy examine all possible parenthezations n P(n)= P(k)P(n k) k= Solution to the recurrence P(n)= Ω( n /n / ) 8

39 // Matrix hain Multiplication Substructure property k k + n Total cost will be cost of solving the two subproblems and multiplying the two resulting matrices ( k )( k + n ) Optimal substructure find the split which will yield the minimal total cost Idea: try to define it recursively Matrix hain Multiplication Define the cost recursively m[i,j] cost of multiplying i j $ & if i = j, m[i, j] = % min{m[i,k] + m[k +, j] + p i p k p j } otherwise '& i k< j 9

40 // Matrix hain Multiplication Option : ompute the cost recursively, remember good splits Draw the recurrence tree for Matrix hain Multiplication Look up the pseudo-code in the textbook ore is the recursive call = RecursiveMatrixhain(p,i,k) + RecursiveMatrixhain(p,k+,j) + Prove by substitution p i p k p j T(n) + (T(k) + T(n k) +) T(n) + n k= n i= T(n) = Ω( n ) T(i) + n Recursive solution would still take exponential time

41 // Matrix hain Multiplication Idea: memoization Look at the recursion tree, many of the sub-problems repeat Remember then and reuse in the n + n How many sub-problems do we have? Why? T(n) = Θ(n ) ompute the solution to all subproblems bottom up Memoize in the table store intermediate cost m[i,j] Matrix hain Multiplication. n = length(p)-. for i= to n m[i,i] = ; % initialize. for l= to n % l is the chain length. for i= to n-l+ % first compute all m[i,i +], then m[i,i+] 5. do j := i+- 6. m[i,j] inf 7. for k = i to j- 8. do q = m[i,k] + m[k+,j] + p(i-)p(k)p(j) 9. if q < m[i,j] then. m[i,j] = q;. s[i,j] = k; % remember k with min cost. end. end. end 5. Return m and s

42 // Example Matrix hain Multiplication Dynamic Programming What is the structure of the sub-problem ommon pattern: Optimal solution requires making a choice which leads to optimal solution Hard part: what is the optimal subproblem structure How many subproblems? How many choices we have which sub-problem to use? Matrix chain multiplication LS

43 // Dynamic Programming What is the structure of the sub-problem ommon pattern: Optimal solution requires making a choice which leads to optimal solution Hard part: what is the optimal subproblem structure How many sub-problems? How many choices we have which sub-problem to use? Matrix chain multiplication: subproblems, j-i choices LS: suproblems choices Subtleties (graph examples) shortest path, longest path Previously Shortest path algorithms: given single source compute shortest path to all other vertices. Dijkstra O( E + V lg V) ellman-ford O(VE) DG O(V+E) ll pairs shortest path: compute shortest path between each pair of nodes Option. Run single source shortest path from each node using previous algorithms Run ellman-ford once for each vertex O(V E) an we do better?

44 // ll pairs shortest path Final representation of the solution is in adjacency matrix δ(i,j) will be the length of the shortest path from i to j Structure of the optimal solution # d ij = $ % if i = j otherwise (m d ) (m ij = min(d ) (m ij,min k n {d ) ik + w kj }) Weight of the shortest path with m- edges and minimum of the weight of any path consisting of at most m edges

45 // Example all shortest paths D () D () D () = W D () = D () W = WW D () = D () W = D () WW Matrix multiplication Repeated Squaring Θ(n ) Θ(n lgn) (m d ) (m ij = min(d ) (m ij,min k n {d ) ik + w kj }) Like matrix multiplication + => min. => + Example all shortest paths D () D () D () D () D () = W D () = D () W = WW D () = D () W = D () WW Matrix multiplication Θ(n ) Repeated Squaring Θ(n lgn) 5