Section 7: Dijkstra s

Transcription

1

2 Section 7: ijkstra s Slides by lex Mariakakis with material Kellen onohue, avid Mailhot, and an rossman

3 Late days Things to iscuss o cse33-lateday@cs.washington.edu o 3 assignments left o an use late days max per assignment Midterm o Loop invariant question

4 Homework 7 Modify your graph to use generics o Will have to update HW #5 and HW #6 tests Implement ijkstra s algorithm o Search algorithm that accounts for edge weights o Note: This should not change your implementation of raph. ijkstra s is performed on a raph, not within a raph. The more well-connected two characters are, the lower the weight and the more likely that a path is taken through them o The weight of an edge is equal to the inverse of how many comic books the two characters share o x: If mazing moeba and Zany Zebra appeared in 5 comic books together, the weight of their edge would be /5

5 Review: Shortest Paths with BFS B From Node B estination Path ost <B,> B <B> 0 <B,,> <B,> <B,,>

6 Shortest Paths with Weights B From Node B estination Path ost <B,> B <B> 0 6 <B,,> 5 <B,,,> 7 <B,,,> 7 Paths are not the same!

7 BFS vs. ijkstra s BFS doesn t work because path with minimal cost path with fewest edges ijkstra s works if the weights are non-negative What happens if there is a negative edge? o Minimize cost by repeating the cycle forever

8 ijkstra s lgorithm Named after its inventor dsger ijkstra (930-00) o Truly one of the founders of computer science; this is just one of his many contributions The idea: reminiscent of BFS, but adapted to handle weights o row the set of nodes whose shortest distance has been computed o Nodes not in the set will have a best distance so far o priority queue will turn out to be useful for efficiency

9 ijkstra s lgorithm. For each node v, set v.cost = and v.known = false. Set source.cost = 0 3. While there are unknown nodes in the graph a) Select the unknown node v with lowest cost b) Mark v as known c) For each edge (v,u) with weight w, c = v.cost + w c = u.cost if(c < c) u.cost = c u.path = v // cost of best path through v to u // cost of best path to u previously known // if the new path through v is better, update

10 xample # 0 B 3 F Order dded to Known Set: H Y 0 B F H

11 0 B Order dded to Known Set: xample # 3 F 3 H Y 0 B F H

12 0 B Order dded to Known Set:, xample # 3 F 3 H Y 0 B Y F H

13 0 B 3 F H Order dded to Known Set:, xample # Y 0 B Y F H

14 0 B 3 F H Order dded to Known Set:,, B xample # Y 0 B Y Y F H

15 0 B F xample # H Y 0 B Y Y Order dded to Known Set:,, B F B H

16 0 B F xample # H Y 0 B Y Y Order dded to Known Set: Y,, B, F B H

17 0 B F xample # H Y 0 B Y Y Order dded to Known Set: Y,, B,, F F Y B H

18 xample # 0 7 B 3 F H Order dded to Known Set:,, B,, F Y 0 B Y Y Y F Y B H 7 F

19 xample # 0 7 B 3 F H Order dded to Known Set:,, B,, F, H Y 0 B Y Y Y F Y B H Y 7 F

20 xample # 0 7 B 3 F H Order dded to Known Set:,, B,, F, H Y 0 B Y Y Y F Y B 8 H H Y 7 F

21 xample # 0 7 B 3 F H Order dded to Known Set:,, B,, F, H, Y 0 B Y Y Y F Y B Y 8 H H Y 7 F

22 xample # 0 7 B 3 F H Order dded to Known Set:,, B,, F, H, Y 0 B Y Y Y F Y B Y 8 H H Y 7 F

23 xample # 0 7 B 3 F H Order dded to Known Set:,, B,, F, H,, Y 0 B Y Y Y Y F Y B Y 8 H H Y 7 F

24 Interpreting the Results 0 7 B F 3 H B 3 F H 3 Y 0 B Y Y Y Y F Y B Y 8 H H Y 7 F

25 0 F B Order dded to Known Set: xample # 5 3 Y 0 B F

26 0 3 B F Order dded to Known Set:,,,, B, F, xample # Y 0 B Y 3 Y Y Y F Y Y 6

27 Pseudocode ttempt # dijkstra(raph, Node start) { for each node: x.cost=infinity, x.known=false start.cost = 0 while(not all nodes are known) { b = dequeue b.known = true for each edge (b,a) in { if(!a.known) { if(b.cost + weight((b,a)) < a.cost){ a.cost = b.cost + weight((b,a)) a.path = b } } brackets O( V ) O( V ) O( ) O( V )

28 an We o Better? Increase efficiency by considering lowest cost unknown vertex with sorting instead of looking at all vertices PriorityQueue is like a queue, but returns elements by lowest value instead of FIFO

29 Priority Queue Increase efficiency by considering lowest cost unknown vertex with sorting instead of looking at all vertices PriorityQueue is like a queue, but returns elements by lowest value instead of FIFO Two ways to implement:. omparable a) class Node implements omparable<node> b) public int compareto(other). omparator a) class Nodeomparator extends omparator<node> b) new PriorityQueue(new Nodeomparator())

30 Pseudocode ttempt # dijkstra(raph, Node start) { for each node: x.cost=infinity, x.known=false O( V ) start.cost = 0 build-heap with all nodes while(heap is not empty) { O( V log V ) b = deletemin() if (b.known) continue; b.known = true for each edge (b,a) in { O( log V ) if(!a.known) { add(b.cost + weight((b,a)) ) } brackets O( log V )

31 Proof of orrectness ll the known vertices have the correct shortest path through induction o Initially, shortest path to start node has cost 0 o If it stays true every time we mark a node known, then by induction this holds and eventually everything is known with shortes path Key fact: When we mark a vertex known we won t discover a shorter path later o Remember, we pick the node with the min cost each round o Once a node is marked as known, going through another path will only add weight o Only true when node weights are positive