elementary graph algorithms n.
Skip this Video
Loading SlideShow in 5 Seconds..
Elementary Graph Algorithms PowerPoint Presentation
Download Presentation
Elementary Graph Algorithms

Loading in 2 Seconds...

play fullscreen
1 / 19

Elementary Graph Algorithms - PowerPoint PPT Presentation

  • Uploaded on

Elementary Graph Algorithms. Peter Schröder. Representations. For graphs G=(V,E) adjacency list for every vertex v list Adj[v] better for sparse graphs: size of O(max(E,V)) adjacency matrix A: a ij =1 if (v i ,v j ) in E single bit entry for each edge in |V|x|V| matrix

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Elementary Graph Algorithms' - hans

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
  • For graphs G=(V,E)
    • adjacency list
      • for every vertex v list Adj[v]
      • better for sparse graphs: size of O(max(E,V))
    • adjacency matrix A: aij=1 if (vi,vj) in E
      • single bit entry for each edge in |V|x|V| matrix
      • better for dense graphs: size is O(|V|2)
    • meaning of A2?
breadth first search
Breadth First Search
  • Given a graph G=(V,E) and a distinguished vertex s in V
    • discover every vertex reachable from s
    • find shortest path from s
    • the name reflects the fact that all vertices at distance k-1 are discovered before any at distance k are discovered
    • 3 colors
      • white: undiscovered; gray: discovered; black: all neighbors have been discovered
breadth first tree
Breadth First Tree
  • Incremental buildup of a tree with a predecessor relationship


for( u in V[G]-{s} )

color[u] = white; d[u] = infinity; p[u] = nil;

color[s] = gray; d[s] = 0; p[s] = nil; Q = {s}

while( Q != {} )

u = head[Q]

for( v in Adj[u] )

if( color[v] == white )

color[v] = gray; d[v] = d[u]+1; p[v] = u;



color[u] = black

  • Running time?
  • Shortest paths
    • Lemma 1: Let G=(V,E) be (un-)directed, s in V arbitrary. Then for any (u,v) in E: ∂(s,v)≤ ∂(s,u)+1
    • Lemma 2: Let G=(V,E) be (un-)directed, suppose BFS(G,s) is run. Then upon termination d[v]≥ ∂(s,v) for all v in V
  • Shortest paths
    • Lemma 3: Suppose during execution of BFS(G,s) Q contains (v1,v2,…vr). Then d[vr] ≤d[v1]+1 and d[vi] ≤d[vi+1] for i=1,2,…r-1
    • Theorem: Correctness of BFS. Suppose BFS(G,s) is run then every v in V reachable from s is discovered and d[v]= ∂(s,v) upon termination. One of the shortest paths from s to v is given by the shortest path from s to p[v] and the edge (p[v],v)
breadth first trees
Breadth First Trees
  • BFS builds a breadth first tree in the p[] field
    • predecessor subgraph of G=(V,E)
      • Gp(Vp,Ep) where Vp contains all v in V with non-nil p[] field plus {s} and Ep contains all predecessor edges for all v in Vp
      • this is a tree. Why?
    • Lemma 5: BFS(G,s) produces a predecessor subgraph which is a breadth first tree
depth first search
Depth First Search
  • Different strategy
    • always go as deep as possible before going on
    • not just a single tree, but a forest results
    • Gp=(V,Ep) where Ep consists of all edges (p[v],v) for any v in V with predecessor field not empty
      • contrast with BFS tree: Gp(Vp,Ep), where Ep depends on Vp not V!
    • there will be no distinguished start vertex
depth first search1
Depth First Search


for( u in V[G] ) color[u] = white; p[u] = nil;

time = 0

for( u in V[G] ) if( color[u] == white ) DFS-visit(u)


color[u] = gray; d[u] = time = time+1;

for( v in adj[u] )

if( color[v] == white )

p[v] = u; DFS-visit(v);

color[u] = black; f[u] = time = time + 1;

  • Running time
  • Correctness
    • Theorem 6: (Parenthesis theorem) In any DFS of a (un-)directed graph G=(V,E) for any pair u,v one of the following holds
      • [d[u],f[u]] and [d[v],f[v]] are entirely disjoint
      • [d[u],f[u]] is contained in [d[v],f[v]] and u is a descencent of v
      • vice versa
    • Corollary 7: descendent intervals are nested
  • Correctness
    • Theorem 8: (White path theorem) In a DFF of a (un-)directed G=(V,E) vertex v is a descendent of u iff at the time d[u] v can be reached from u along a path of white vertices
  • DFS admits classification of edges
    • Tree edges: members of DFF of Gp. (u,v) is a tree edge if v was discovered exploring u
    • Back edges: edges (u,v) connecting a vertex u to an ancestor v (self loops are back edges)
    • Forward edges: non-tree edges (u,v) connecting u to a descendent v
    • Cross edges: all others (c0uld be same tree, could be different trees)
edge types
Edge Types
  • Undirected graphs
    • Theorem 9: in a DFS of an undirected graph G=(V,E) every edge of G is either a tree edge or a back edge
topological sort
Topological Sort
  • For a directed acyclic graph (DAG)
    • a topological sort is a linear ordering of all its vertices such that if G contains (u,v) then u appears before v in the ordering


call DFS(G) to compute finish times

enter vertices onto front of list

according to their finish times

return linked list of vertices

  • Running time
  • Correctness
    • Lemma 10: a directed graph is acyclic iff DFS(G) yields no back edges
    • Theorem 11: Topological-Sort(G) produces a topological sort of a DAG G
a classic problem
A Classic Problem
  • Strongly connected components
    • a strongly connected component of a directed graph G=(V,E) is a maximal subset U of V such that for any u,v in U there is a path from u to v and a path from v to u
      • form the transpose GT (runtime?)
      • u is reachable from v in G iff v is reachable from u in GT


call DFS(G) to compute finish times

compute GT

call DFS(GT) and consider vertices

decreasing finish time order

output vertices of each tree in DFS(GT)

as separate strongly connected component

  • Running time
  • Correctness
    • Lemma 12: if two vertices are in the same SCC then no path between them ever leaves the SCC
    • Theorem 13: in any DFS all vertices in the same SCC are placed in the same DFT
  • Correctness
    • Theorem 14: in a directed graph G=(V,E) the forefather phi(u) of any u in V in any DFS of G is an ancestor of u
    • Corollary 15: in any DFS of a directed graph G=(V,E) vertices u and phi(u) for all u in V lie in the same SCC
    • Theorem 16: in a directed graph G=(V,E) two vertices u,v in V lies in the same SCC iff they have the same forefather in DFS(G)