theory of computing lecture 6 mas 714 hartmut klauck
TRANSCRIPT
![Page 1: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/1.jpg)
Theory of Computing
Lecture 6MAS 714
Hartmut Klauck
![Page 2: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/2.jpg)
Traversing Graphs
• We are given a graph G=(V,E)• Starting vertex s• The goal is to traverse the graph, i.e., to visit each
vertex at least once– For example to find a marked vertex t or decide if t is
reachable from s
• Two variants:– Breadth First Search (BFS)– Depth First Search (DFS)
![Page 3: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/3.jpg)
Traversing Graphs
• Common to both procedures:– Use a datastructure with the following operations:• Insert a vertex• Remove a vertex
– Maintain an active vertex (start with s)– Maintain an array of vertices already visited– Then:• Insert all (unvisited) neighbors of the active vertex,
mark it as visited• Remove a vertex v and make it active
![Page 4: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/4.jpg)
The Datastructure
• We distinguish by the rule that determines the next active vertex
• Alternative 1: queue– FIFO (first in first out)
• Alternative 2: stack– LIFO (last in first out)
![Page 5: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/5.jpg)
Result
• Alternative 1: FIFO– Breadth First Search– Neighbors of s will be visited before their
neighbors etc.
• Alternative 2: LIFO– Depth First Search– Insert neighbors, last neighbor becomes active,
then insert his neighbors, last neighbor becomes active etc.
![Page 6: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/6.jpg)
Traversing Graphs
• With both methods eventually all reachable vertices are visited
• Different applications:– BFS can be used to find shorted paths in
unweighted graphs– DFS can be used to topologically sort a directed
acyclic graph
![Page 7: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/7.jpg)
Depth First Search
• If we use a stack as datastructure we get Depth First Search (DFS)
• Typically, DFS will maintain some extra information:– Time when v is put on the stack– Time, when all neighbors of v have been examined
• This information is useful for applications
![Page 8: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/8.jpg)
Datastructure: Stack
• A stack is a linked list together with two operations– push(x,S): Insert element x at the front of the list S– pop(S): Remove the front element of the list S
• Implementation:– Need to maintain only the pointer to the front of
the stack– Useful to also have • peek(S): Find the front element but don’t remove
![Page 9: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/9.jpg)
Digression: Recursion and Stacks
• Our model of Random Access Machines does not directly allow recursion– Neither does any real hardware
• Compilers will “roll out” recursive calls– Put all local variables of the calling procedure in a
safe place– Execute the call– Return the result and restore the local variables
![Page 10: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/10.jpg)
Recursion
• The best datastructure for this is a stack– Push all local variables to the stack– LIFO functionality is exactly the right thing
• Example: Recursion tree of Quicksort
![Page 11: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/11.jpg)
DFS
• Procedure:1. For all v:• ¼(v)=NIL, d(v)=0, f(v)=0
2. Enter s into the stack S, set TIME=1, d(s)=TIME3. While S is not empty
a) v=peek(S)b) Find the first neighbor w of v with d(w)=0:
– push(w,S) , ¼(w)=v, TIME=TIME+1, d(w)=TIME
c) If there is no such w: pop(S), TIME=TIME+1, f(v)=TIME
![Page 12: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/12.jpg)
DFS
• The array d(v) holds the time we first visit a vertex.
• The array f(v) holds the time when all neighbors of v have been processed
• “discovery” and “finish”• In particular, when d(v)=0 then v has not been
found yet
![Page 13: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/13.jpg)
Simple Observations
• Vertices are given d(v) numbers between 1 and 2n
• Each vertex is put on the stack once, and receives the f(v) number once all neighbors are visited
• Running time is O(n+m)
![Page 14: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/14.jpg)
A recursive DFS
• Stacks are there to roll out recursion• Consider the procedure in a recursive way!• Furthermore we can start DFS from all unvisited vertices to
traverse the whole graph, not just the vertices reachable from s
• We also want to label edges– The edges in (¼(v),v) form trees: tree edges– We can label all other edges as
• back edges• cross edges• forward edges
![Page 15: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/15.jpg)
Edge classification
• Lemma: the edges (¼(v),v) form a tree• Definition:
– Edges going down along a path in a tree (but not tree edge) are forward edges
– Edges going up along a path in a tree areback edges
– Edges across paths/tree are cross edges
• A vertex v is a descendant of u if there is a path of tree edges from u to v
• Observation: descendants are discovered after their “ancestors” but finish before them
![Page 16: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/16.jpg)
Example: edge labeling
• Tree edges, Back edges, Forward edges, Cross edges
![Page 17: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/17.jpg)
Recursive DFS
• DFS(G):1. TIME=1 (global variable)2. For all v: ¼(v)=NIL, d(v)=0, f(v)=03. For all v: if d(v)=0 then DFS(G,v)
• DFS(G,v)1. TIME=TIME+1, d(v)=TIME 2. For all neighbors w of v:
1. If d(w)=0 then (v,w) is tree edge, DFS(G,w)2. If d(w)0 and f(w)0 then cross edge or forward edge3. If d(w)0 and f(w)=0 then back edge
3. TIME=TIME+1, f(v)=TIME
![Page 18: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/18.jpg)
Recursive DFS
• How to decide if forward or cross edge?– Assume, (v,w) is an edge and f(w) is not 0– If d(w)>d(v) then forward edge– If d(v)>d(w) then cross edge
![Page 19: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/19.jpg)
Application 1: Topological Sorting
• A DAG is a directed acyclic graph– A partial order on vertices
• A topological sorting of a DAG is a numbering of vertices s.t. all edges go from smaller to larger vertices– A total order that is consistent with the partial
order
![Page 20: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/20.jpg)
DAGs
• Lemma: G is a DAG iff there are no back edges– Proof:• If there is a back edge, then there is a cycle• The other direction: suppose there is a cycle c• Let u be the first vertex discovered on c• v is u’s predecessor on c• Then v is a descendant of u, i.e., d(v)>d(u) and f(v)<f(u)• When edge (v,u) is processed: f(u)=0, d(v)>d(u)• Thus (v,u) is a back edge
![Page 21: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/21.jpg)
Topological Sorting
• Algorithm:– Output the vertices in the reverse order of the f(v)
as the topological sorting of G
• I.e., put the v into a list when they finish in DFS, so that the last finished vertex is first in list
![Page 22: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/22.jpg)
Topological Sorting
• We need to prove correctness– Certainly we provide a total ordering of vertices– Now assume vertex i is smaller than j in the ordering– I.e., i finished after j– Need to show: there is no path from j to i– Proof:
• j finished means all descendants of j are finished• Hence i is not a descendant of j (otherwise i finishes first)• If j is a descendant of i then a path from j to i must contain a back
edge (but those do not exist in a DAG)• If j is not a descendant of i then a path from j to i contains a cross
edge, but then f(i)< f(j)
![Page 23: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/23.jpg)
Topological Sorting
• Hence we can compute a topological sorting in linear time
![Page 24: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/24.jpg)
Application 2: Strongly connected components
• Definition:– A strongly connected component of a graph G is a
maximal set of vertices V’ such that for each pair of vertices v,w in V’ there is a path from v to w
• Note: in undirected graphs this corresponds to connected components, but here we have one-way roads
• Strongly connected components (viewed as vertices) form a DAG inside a graph G
![Page 25: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/25.jpg)
Strongly connected components
• Algorithm– Use DFS(G) to compute finish times f(v) for all v– Compute GT [Transposed graph: edges (u,v)
replaced by (v,u)]– Run DFS(GT), but in the DFS procedure go over
vertices in order of decreasing f(v) from the first DFS
– Vertices in a tree generated by DFS(GT) form a strongly connected component
![Page 26: Theory of Computing Lecture 6 MAS 714 Hartmut Klauck](https://reader036.vdocuments.mx/reader036/viewer/2022062421/56649cb95503460f949812d3/html5/thumbnails/26.jpg)
Strongly connected components
• Time: O(n+m)• We skip the correctness proof• Note the usefulness of the f(v) numbers
computed in the first DFS