Graph Representations

• Adjacency List
• Adjacency Matrix
• Variants:
1. Directed Graphs
2. Weighted Graphs
3. Weighted Digraphs
• Graph as Index

Breadth First Search

• Assumptions / Resources

Graph in adjacency list representation (vertices indexed 0,1,...n-1)
s = start vertex
Vector < color_type > color    // color[v] used in algorithm body
Vector < vertex     > parent   // parent[v] computed by algorithm
Vector < int        > distance // distance[v] = number of edges between start and v by algorithm
Queue  < vertex     > Q        // algorithm control structure

• Body

// startup phase
for(each vertex except s)
{
  color[v] = white;
  distance[v] = infinity;
  parent[v] = NIL;
}
color[s] = gray;
distance[s] = 0;
parent[s] = 0;
Q.MakeEmpty();
Q.Push(s);

// search phase
while (!Q.Empty())
{
  u = Q.Pop();
  for each v in ADJ[u]
  {
    if (color[v] = white)
    {
      color[v] = gray;
      distance[v] = distance[u] + 1;
      parent[v] = u;
      Q.Push(v);
    }
  }
  color[u] = black;
}

• Analysis
1. Q contains exactly the gray vertices
2. No vertex is ever changed to white (after initialization)
3. Therefore: vertex is pushed at most one, hence popped at most once
4. Therefore total time of Queue operations is O(V)
5. ADJ[u] is scanned only when u is popped - one time only
6. Therefore total time scanning adjacency lists is O(E)
7. Therefore runtime of DFS is O(V + E)
• Note that size(G) = Θ(V + E), so this is asytmtotically the same runtime as a traversal
• (Re-)Constructing The BFS Tree
• BFS Theorem:
1. distance[v] < infinity iff v is reachable from s
2. distance[v] is the length of a shortest path from s to v
3. If v is reachable from s, the BFS tree path from s to v is a shortest path from s to v
• BFS on DiGraphs

Depth First Search

• Assumptions / Resources

Graph or Digraph in adjacency list representation (vertices indexed 0,1,...n-1)
s = start vertex
Vector < color_type > color    // color[v] used in algorithm body
Vector < vertex     > parent   // parent[v] computed by algorithm
Vector < int        > d        // d[v] = discovery time - when color changes to gray
Vector < int        > f        // f[v] = finish time  - when color color changes to black
Stack  < vertex     > Q        // algorithm control structure
unsigned int          time     // increments at each color change

• Body

// startup phase
for(each vertex v)
{
  color[v] = white;
  parent[v] = NIL;
}
time = 0;


// search phase - one vertex s
if (color[s] == white)
  color[s] = gray;
parent[s] = 0;
++time;
d[s] = time;
Q.MakeEmpty();
Q.Push(s);

while (!Q.Empty())
{
  u = Q.Top();
  if (v in ADJ[u] && color[v] == white)
  {
    color[v] = gray;
    ++ time;
    d[v] = time;
    parent[v] = u;
    Q.Push(v);
  }
  else
  {
    color[u] = black;
    ++time;
    Q.Pop();
    f[u] = time;
  }
}

• Analysis
1. Q contains exactly the gray vertices
2. No vertex is ever changed to white (after initialization)
3. Therefore: vertex is pushed at most one, hence popped at most once
4. Therefore total time of Queue operations is O(V)
5. ADJ[u] is scanned only when u is popped - one time only
6. Therefore total time scanning adjacency lists is O(E)
7. Therefore runtime of DFS is O(V + E)
• Note that size(G) = Θ(V + E), so this is asytmtotically the same runtime as a traversal
• (Re-)Constructing The DFS Forrest
• DFS Theorem:
1. d[v] is time v is pushed onto the stack
2. f[v] is time v is popped off of the stack
3. For a vertex v let I(v) = [d[v], f[v], the interval of time that v is gray (on the stack). Then for any u,v, exactly one of these statements holds:
• I(u) and I(v) are disjoint: u and v are not in the same tree of the DFS forrest
• I(u) is a subset of I(v): u is a descendant of v in the DFS forrest
• I(u) is a superset of I(v): u is an ancester of v in the DFS forrest
4. Vertex v is a proper descendant of u in the DFS forrest iff at time d[u], v is reachable from u along a path of white vertices.
• Four edge types:
1. Tree Edges: Edges in the DFS forrest
2. Back Edges: Edges from a vertex to an ancester in the DFS forrest
3. Forward Edges: Non-tree edges from a vertex to a descendant in the DFS forrest
4. Cross Edges: All other edges
• Modify DFS to classify edges as vertices are discovered
1. to white vertex ==> tree edge
2. to gray vertex ==> back edge
3. to black vertex ==> forward or cross edge
• After DFS of an undirected graph, there are no forward or cross edges

Topological Sort

• Directed Acyclic Graph (DAG)
• Theorem: Digraph G is a DAG iff DFS yields no back edges
• Topological Sort Algorithm:
1. Perform DFS
2. EnQueue vertices in finishing order
• Top Sort Theorem: After Top Sort Alg, Output Queue contains all vertices iff

Minimum Spanning Trees

• Generic-MST(G,w)

set A;  // build up the MST here
A.MakeEmpty()
while (A is not spanning tree)
{
  find safe edge e for A
  A.Insert(e)
  return A
}

• If A is a subset of a MST for (G,w), a safe edge for A is an edge that A.Insert(e) is a subset of a MST for (G,w).
• Kruskal: greedy algorithm with A a MSForrest
• Prim: greedy algorithm with A a MSTree

Single-Source Shortest Paths

All-Pairs Shortest Paths