Recommended Lecture Video: UCB Lecture Graphs 1

Graph Representations

• Adjacency List
• Adjacency Matrix
• Variants:
1. Directed Graphs
2. Weighted Graphs
3. Weighted Digraphs (Networks)
• Graph as Index/Control Structure

Breadth First Search

• Assumptions / Resources

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

• Body

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

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

• BFS as a Class

class BFS
{

  typedef unsigned int Vertex;

private: // reference to structure being searched
  GraphBase& g_; // adjacency list representation (vertices indexed 0,1,...n-1)
  Vertex     s_; // starting search here

private: // control variables
  Vector < ColorType > color_;    
  Queue  < Vertex    > conQueue_; 

public:  // informational variables
  Vector < Vertex    > parent_;   // = parent in BFS tree
  Vector < int       > distance_; // = distance from start

public:  // methods
  void Init(Vertex startHere)
  {
    s_ = startHere;
    for(each vertex v of g_ except possibly s_)
    {
      color_[v] = white;
      distance_[v] = infinity;
      parent_[v] = NIL;
    }
    color_[s_] = gray;
    distance_[s_] = 0;
    parent_[s_] = NIL;
    conQueue_.MakeEmpty();
    conQueue_.Push(s_);
  }

  void Run()
  {
    while (!conQueue_.Empty())
    {
      u = conQueue_.Pop();
      for each v in g_.ADJ[u]
      {
        if (color_[v] = white)
        {
          color_[v] = gray;
          distance_[v] = distance_[u] + 1;
          parent_[v] = u;
          conQueue_.Push(v);
        } //  if
      } // for
      color_[u] = black;
    } // while
  }
};

• Analysis
1. conQueue_ 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 BFS is O(V + E)
• Note that size(G) = Θ(V + E), so this is asymptotically 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

• DFS as a Class

class DFS
{

  typedef unsigned int Vertex;

private:
  GraphBase& g_;     // adjacency list representation (vertices indexed 0,1,...n-1)
  Vertex     start_; // starting search here
  Stack  < Vertex    > conStack_; 
  Vector < ColorType > color_;    
  unsigned int         time_;     // increments at each color change

public:
  Vector < Vertex    > parent_;   // parent in DFS forrest
  Vector < int       > d_;        // discovery time - when color changes to gray
  Vector < int       > f_;        // finish time  - when color color changes to black

public:
  void Init(Vertex startHere)
  {
    start_ = startHere;
    for(each vertex v)
    {
      color_[v] = white;
      parent_[v] = NIL;
    }
    time_ = 0;
    conStack_.MakeEmpty();
  }

private:
  void Run(Vertex s)
  {
    color_[s] = gray;
    parent_[s] = NIL;
    ++time_;
    d_[s] = time_;
    conStack_.Push(s);
    while (!conStack_.Empty())
    {
      u = conStack_.Top();
      if (there exists v in ADJ[u] such that color_[v] == white)
      {
        color_[v] = gray;
        ++time_;
        d_[v] = time_;
        parent_[v] = u;
        conStack_.Push(v);
      }
      else
      {
        color_[u] = black;
        conStack_.Pop();
        ++time_;
        f_[u] = time_;
      }
    }
  } // Run(s)

public: // traditionally DFS is run until all vertices have been discovered
  void Run()
  {
    Run(start_);
    while (there is a white vertex s)
      Run(s);
  } // Run()
};

• Analysis
1. conStack_ 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 conStack_ 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

Space requirements

• DFS runspace = +O(q) where q = maximum size of conQueue
• BFS runspace = +O(s) where s = maximum size of conStack
• q = number of vertices with approximately the same distance from start
• s = length of path from start to v
• Typically q = O(n) while s = O(log n) [look at tree example]
• Can result in preference for DFS for very large search spaces

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 is performed on digraph G, Output Queue contains all vertices iff G is acyclic

class TopSort : public DFS
{
  // DFS::Run()
  // then enque vertices in order of f_ value
};

Topologiocal Sort 2

class TopSort2
{
private:
  DiGraph& d_;
  Vector v_ of integers; // stores "unused" inDegree of each vertex (initialized to inDegree) 
  Stack  s_ of vertices; // stores vertices with no "unused" inDegree for processing

public:
  Queue  q_ of vertices; // stores topological ordering of vertices (initialized empty) 

  void Init()
  {
    q_.Clear();
    s_.Clear();
    for (i = 0; i < d_.VrtxSize(); ++i)
    {
      v_[i] = d_.InDeg(i);
      if (v_[i] == 0)
        s_.Push(i);
    }
  }

  void Sort()
  {
    While (!s_.Empty())
    {
      t = s_.Top();
      s_.Pop();
      for every neighbor n of t
      { 
        --v_[n];
        if (v_[n] == 0)
          s_.Push(n);
      }
      q_.Push (t);
    }
    if (q_.Size() == d_.VrtxSize())
      q_ contains a topological ordering of d_;
    else
      d_ has a cycle;
  }

// Replace stack with queue to preserve order of discovery 
// Replace stack with priority queue if vertices have "preferred" order 
};

---