Download presentation

Presentation is loading. Please wait.

1
Chapter 9: Graphs Summary Mark Allen Weiss: Data Structures and Algorithm Analysis in Java Lydia Sinapova, Simpson College

2
2 Summary of Graph Algorithms Basic Concepts Topological Sort Shortest Paths Spanning Trees Scheduling Networks Breadth-First and Depth First Search Connectivity

3
3 Basic Concepts Basic definitions: vertices and edges More definitions: paths, simple paths, cycles, loops Connected and disconnected graphs Spanning trees Complete graphs Weighted graphs and networks Graph representation Adjacency matrix Adjacency lists

4
4 Topological Sort RULE: If there is a path from u to v, then v appears after u in the ordering. Graphs: directed, acyclic Degree of a vertex U: the number of outgoing edges Indegree of a vertex U: the number of incoming edges The algorithm for topological sort uses "indegrees" of vertices. Implementation: with a queue Complexity: Adjacency lists: O(|E| + |V|), Matrix representation: O(|V| 2 )

5
5 Shortest Path in Unweighted Graphs Data Structures needed: Distance Table Queue Implementation: Breadth-First search using a queue Complexity: Matrix representation: O(|V|2) Adjacency lists - O(|E| + |V|)

6
6 Algorithm 1.Store s in a queue, and initialize distance = 0 in the Distance Table 2. While there are vertices in the queue: Read a vertex v from the queue For all adjacent vertices w : If distance = -1 (not computed) Distance = (distance to v) + 1 Parent = v Append w to the queue

7
7 Shortest Path in Weighted Graphs – Dijkstra’s Algorithm s distance = 0 1. Store s in a priority queue with distance = 0 2. While there are vertices in the queue DeleteMin v DeleteMin a vertex v from the queue w For all adjacent vertices w : Compute new distance Store in / update Distance table Insert/update in priority queue

8
8 Complexity O(E logV + V logV) = O((E + V) log(V)) Each vertex is stored only once in the queue – O(V) DeleteMin operation is : O( V logV ) Updating the priority queue – search and inseart: O(log V) performed at most for each edge: O(E logV)

9
9 Spanning Trees Spanning tree: a tree that contains all vertices in the graph. Number of nodes: |V| Number of edges: |V|-1

10
10 Spanning Trees of Unweighted Graphs Breadth-First Search using a queue Complexity: O(|E| + |V|) - we process all edges and all nodes

11
11 Min Spanning Trees of Weighted Graphs – Prim’s Algorithm Find a spanning tree with the minimal sum of the weights. Similar to shortest paths in a weighted graphs. Difference: we record the weight of the current edge, not the length of the path. Implementation: with a Priority Queue Complexity: O(|E| log (|V|) )

12
12 Min Spanning Trees of Weighted Graphs – Kruskal’s Algorithm The algorithm works with the set of edges, stored in Priority queue. The tree is built incrementally starting with a forest of nodes only and adding edges as they come out of the priority queue Complexity: O(|E| log (|V|))

13
13 Scheduling Networks Directed simple acyclic graph Nodes: events, Source, Sink Edges: activities (name of the task, duration) Find the earliest occurrence time (EOT) of an event Find the earliest completion time (ECT) of an activity Find the slack of an activity: how much the activity can be delayed without delaying the project Find the critical activities: must be completed on time in order not to delay the project

14
14 EOT and ECT Earliest occurrence time of an event EOT(source) = 0 EOT( j ) = max ( EOTs of all activities preceding the event) Earliest completion time of an activity ECT( j, k ) = EOT( j ) + duration( j, k) 1. Sort the nodes topologically 2. For each event j : initialize EOT(j) = 0 3. For each event i in topological order For each event j adjacent from i : ECT(i,j) = EOT(i) + duration (i,j) EOT(j) = max(EOT(j), ECT(i,j))

15
15 Slack of activities Compute latest occurrence time LOT(j), slack(i, j) 1. InitializeLOT(sink) = EOT(sink) 2. For each non-sink event i in the reverse topological order: LOT(i) = min(LOT( j ) – duration( i, j)) 3. For each activity (i,j) slack( i, j ) = LOT( j ) – ECT( i, j) Critical activities: slack(j) = 0 Critical path in the project: all edges are activities with slack = 0 The critical path is found using breadth-first (or depth-first) search on the edges Complexity: O(V + E) with adjacency lists, O(V 2 ) with adjacency matrix

16
16 BFS and DFS bfs(G) list L = empty tree T = empty choose a starting vertex x visit(x) while(L nonempty) remove edge (v,w) from beginning of L if w not visited add (v,w) to T visit(w) dfs(G) list L = empty tree T = empty choose a starting vertex x visit(x) while(L nonempty) remove edge (v,w) from end of L if w not visited add (v,w) to T visit(w) Visit ( vertex v ) mark v as visited for each edge (v,w) add edge (v,w) to end of L Complexity: O( V + E)

17
17 Graph Connectivity Connectivity Biconnectivity – no cut vertices Articulation Points and Bridges Connectivity in Directed Graphs Strongly connected Unilaterally connected Weakly connected

Similar presentations

© 2021 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google