04/03/03 Lecture 20 1

Transcription

1 Figure 14.2 Adjacency list representation of the graph shown in Figure 14.1; the nodes in list i represent vertices adjacent to i and the cost of the connecting edge. 04/03/03 Lecture 20 1

2 Shortest Paths Suppose we are interested in the shortest paths (and their lengths) from vertex Miami to all other vertices in the graph. We need to augment the data structure to store this information. 04/03/03 Lecture 20 2

3 Figure 14.4 An abstract scenario of the data structures used in a shortest-path calculation, with an input graph taken from a file. The shortest weighted path from A to C is A to B to E to D to C (cost is 76). 04/03/03 Lecture 20 3

4 Vertex Object // Represents a vertex in the graph. class Vertex { public String name; // Vertex name public List adj; // Adjacent vertices public double dist; // Cost public Vertex prev; // Previous vertex on shortest path public int scratch;// Extra variable used in algorithm public Vertex( String nm ) { name = nm; adj = new LinkedList( ); reset( ); public void reset( ) { dist = Graph.INFINITY; prev = null; pos = null; scratch = 0; public PriorityQueue.Position pos; // Used for dijkstra2 04/03/03 Lecture 20 4

5 Edge Object // Represents an edge in the graph. class Edge { public Vertex dest; // Second vertex in Edge public double cost; // Edge cost public Edge( Vertex d, double c ) { dest = d; cost = c; 04/03/03 Lecture 20 5

6 Graph Object // Graph class: evaluate shortest paths. // // CONSTRUCTION: with no parameters. // // ******************PUBLIC OPERATIONS********* // void addedge( String v, String w, double cvw ) // --> Add additional edge // void printpath( String w ) --> Print path after alg is run // void unweighted( String s ) --> Single-source unweighted // void dijkstra( String s ) --> Single-source weighted // void negative( String s ) --> Single-source negative weighted // void acyclic( String s ) --> Single-source acyclic 04/03/03 Lecture 20 6

7 getvertex Method public class Graph { public static final double INFINITY = Double.MAX_VALUE; private Map vertexmap = new HashMap( ); // Maps String to Vertex /** If vertexname is not present, add it to vertexmap. * * In either case, return the Vertex. */ private Vertex getvertex( String vertexname ) { Vertex v = (Vertex) vertexmap.get( vertexname ); if( v == null ) { v = new Vertex( vertexname ); vertexmap.put( vertexname, v ); return v; 04/03/03 Lecture 20 7

8 addedge Method /** * Add a new edge to the graph. */ public void addedge( String sourcename, String destname, double cost ) { Vertex v = getvertex( sourcename ); Vertex w = getvertex( destname ); v.adj.add( new Edge( w, cost ) ); 04/03/03 Lecture 20 8

9 printpath Method /** * Recursive routine to print shortest path to dest * after running shortest path algorithm. The path * is known to exist. */ private void printpath( Vertex dest ) { if( dest.prev!= null ) { printpath( dest.prev ); System.out.print( " to " ); System.out.print( dest.name ); 04/03/03 Lecture 20 9

10 /** clearall Method * Initializes the vertex output info prior to running * any shortest path algorithm. */ private void clearall( ) { for( Iterator itr = vertexmap.values( ).iterator( ); itr.hasnext( ); ) ( (Vertex)itr.next( ) ).reset( ); 04/03/03 Lecture 20 10

11 /** Unweighted Shortest Path Problem * A main routine that: * 1. Reads a file containing edges (supplied as a commandline parameter); * 2. Forms the graph; * 3. Repeatedly prompts for two vertices and * runs the shortest path algorithm. * The data file is a sequence of lines of the format * source destination. */ 04/03/03 Lecture 20 11

12 Figure 14.5 Data structures used in a shortest-path calculation, with an input graph taken from a file; the shortest weighted path from A to C is A to B to E to D to C (cost is 76). Legend: Dark-bordered boxes are Vertex objects. The unshaded portion in each box contains the name and adjacency list and does not change when shortest-path computation is performed. Each adjacency list entry contains an Edge that stores a reference to another Vertex object and the edge cost. Shaded portion is dist and prev, filled in after shortest path computation runs. Dark arrows emanate from vertexmap. Light arrows are adjacency list entries. Dashed arrows are the prev data member that results from a shortest-path computation. 04/03/03 Lecture 20 12

13 Figure The graph, after the starting vertex has been marked as reachable in zero edges 04/03/03 Lecture 20 13

14 Figure The graph, after all the vertices whose path length from the starting vertex is 1 have been found 04/03/03 Lecture 20 14

15 Figure The graph, after all the vertices whose shortest path from the starting vertex is 2 have been found 04/03/03 Lecture 20 15

16 Figure The final shortest paths 04/03/03 Lecture 20 16

17 Figure If w is adjacent to v and there is a path to v, there also is a path to w 04/03/03 Lecture 20 17

18 Figure 14.21A Searching the graph in the unweighted shortest-path computation. The darkest-shaded vertices have already been completely processed, the lightest-shaded vertices have not yet been used as v, and the mediumshaded vertex is the current vertex, v. The stages proceed left to right, top to bottom, as numbered (continued). 04/03/03 Lecture 20 18

19 Figure 14.21B Searching the graph in the unweighted shortest-path computation. The darkest-shaded vertices have already been completely processed, the lightest-shaded vertices have not yet been used as v, and the mediumshaded vertex is the current vertex, v. The stages proceed left to right, top to bottom, as numbered. 04/03/03 Lecture 20 19

20 public static void main( String [ ] args ) { Graph g = new Graph( ); BufferedReader graphfile=new BufferedReader(FileReader( args[0] ) ); // Read the edges and insert String line; while( ( line = graphfile.readline( ) )!= null ) { StringTokenizer st = new StringTokenizer( line ); if( st.counttokens( )!= 3 ) { // some error message String source = st.nexttoken( ); String dest = st.nexttoken( ); int cost = Integer.parseInt( st.nexttoken( ) ); g.addedge( source, dest, cost ); // Read the queries BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) ); while( processrequest( in, g ) ) ; // while loop body is empty 04/03/03 Lecture 20 20

21 processrequest Method public static boolean processrequest( BufferedReader in, Graph g ) { String startname = null, destname = null, alg = null; System.out.print( "Enter start node:" ); if( ( startname = in.readline( ) ) == null ) return false; System.out.print( "Enter destination node:" ); if( ( destname = in.readline( ) ) == null ) return false; g.unweighted( startname ); // changes with algorithm g.printpath( destname ); return true; 04/03/03 Lecture 20 21

22 SP unweighted graphs public void unweighted( String startname ) { clearall( ); Vertex start = (Vertex) vertexmap.get( startname ); LinkedList q = new LinkedList( ); q.addlast( start ); start.dist = 0; while(!q.isempty( ) ) { Vertex v = (Vertex) q.removefirst( ); for( Iterator itr = v.adj.iterator( ); itr.hasnext( ); ) { Edge e = (Edge) itr.next( ); Vertex w = e.dest; if( w.dist == INFINITY ) { w.dist = v.dist + 1; w.prev = v; q.addlast( w ); 04/03/03 Lecture 20 22

23 Figure The eyeball is at v and w is adjacent, so D w should be lowered to 6. 04/03/03 Lecture 20 23

24 Figure If D v is minimal among all unseen vertices and if all edge costs are nonnegative, D v represents the shortest path. 04/03/03 Lecture 20 24

25 Figure 14.25A Stages of Dijkstra s algorithm. The conventions are the same as those in Figure (continued). 04/03/03 Lecture 20 25

26 Figure 14.25B Stages of Dijkstra s algorithm. The conventions are the same as those in Figure /03/03 Lecture 20 26

27 Class Path // Represents an entry in the priority queue for Dijkstra's algorithm. class Path implements Comparable { public Vertex dest; // w public double cost; // d(w) public Path( Vertex d, double c ) { dest = d; cost = c; public int compareto( Object rhs ) { double othercost = ((Path)rhs).cost; return cost < othercost? -1 : cost > othercost? 1 : 0; 04/03/03 Lecture 20 27

28 public void dijkstra( String startname ) { PriorityQueue pq = new BinaryHeap( ); Vertex start = (Vertex) vertexmap.get( startname ); clearall( ); pq.insert( new Path( start, 0 ) ); start.dist = 0; int nodesseen = 0; while(!pq.isempty( ) && nodesseen < vertexmap.size( ) ) { Path vrec = (Path) pq.deletemin( ); Vertex v = vrec.dest; if( v.scratch!= 0 ) continue; // already processed v v.scratch = 1; nodesseen++; for( Iterator itr = v.adj.iterator( ); itr.hasnext( ); ) { Edge e = (Edge) itr.next( ); Vertex w = e.dest; double cvw = e.cost; if( w.dist > v.dist + cvw ) { w.dist = v.dist +cvw; w.prev = v; pq.insert( new Path( w, w.dist ) ); 04/03/03 Lecture 20 28

29 Figure 14.30A A topological sort. The conventions are the same as those in Figure (continued). 04/03/03 Lecture 20 29

30 Figure 14.30B A topological sort. The conventions are the same as those in Figure /03/03 Lecture 20 30

31 Figure 14.31A The stages of acyclic graph algorithm. The conventions are the same as those in Figure (continued). 04/03/03 Lecture 20 31

32 Figure 14.31B The stages of acyclic graph algorithm. The conventions are the same as those in Figure /03/03 Lecture 20 32

33 Figure An activity-node graph 04/03/03 Lecture 20 33

34 Figure An event-node graph 04/03/03 Lecture 20 34

35 Figure Earliest completion times 04/03/03 Lecture 20 35

36 Figure Latest completion times 04/03/03 Lecture 20 36

37 Figure Earliest completion time, latest completion time, and slack (additional edge item) 04/03/03 Lecture 20 37

38 Figure Worst-case running times of various graph algorithms 04/03/03 Lecture 20 38