Paths and Connectivity

• Given a graph $G=(V,E)$.
• A path is a sequence of nodes $p = v_1, v_2, v_3, ... v_n$ such that $(v_i, v_{i+1}) \in E ~ \forall ~ 1 \le i \lt n$
  • Generally we assume no $v_i = v_j, i \ne j$.
• A cycle is a sequence of nodes $c=v_1, v_2, ... v_n, v_1$ such that $(v_i, v_{i+1}) \in E ~ \forall ~ 1 \le i \lt n ~ \textrm{and} (v_n, v_1) \in E$
• A graph is connected if for all nodes $(u,v)$, then there is a path from $u$ to $v$
• The distance between two nodes $(u,v)$ is the minimum number of edges in a path from $u$ to $v$.
  • If no path exists, then the distance is $\infty$
• A little more on trees
  • Nodes in trees have parent/child relationships.
  • A node v is a descendant of a node u if there exists a path, from the root through u to v.
  • A node with no descendants is called a leaf node.
• THM: Every n node tree has exactly n-1 edges.

        For every node in a n node tree except the root, there
        must be an edge pointing to the node's parent.
        There are $n-1$ such nodes, thus there must be $n-1$ edges.
  

• The s-t Connectivity problem.
  • Given a graph $G=(V,E)$, and $s\in V, t\in V$ is there a path from s to t?
  • We will examine two algorithms DFS and BFS
• BFS or Breadth first search.
  • General idea:

    start with node s.
    set n = 1
    While node t is not found and there are connected nodes
        explore all nodes n steps away from s
        n++

  • They do a "layer" argument
    • The start node is at layer 0 ($L_0$)
    • All nodes adjacent to s are in layer 1 $(L_1)$
    • At step n, all nodes not in layer $L_0 ... L_n$ which are adjacent to a node in $L_n$ are in layer $L_{n+1}$
  • THM: For each $j \ge 1 $ layer $L_j$ produced by BFS consists of all nodes at a distance exactly j from s. There is a path from s to t if and only if t appears in some layer.
    • Furthermore, we could argue that the path from s to t defined by these layers is the shortest path.
  • As we perform we build a tree
    • Rooted at s.
    • Called the Breadth First Search Tree.
  • BFS:

  • BFS(G,s)
    
     For all v $\ni$ V 
         v.status = UNKNOWN, v.depth = $\infty$
     EndFor
     s.status =  discovered
     s.parent = null
     s.depth = 0
     Q.Enqueue(s)
     While Q.Size() > 0 do
        v = Q.Dequeue()
        v.status = done
        For each u adjacent to v
           If  u.status = unknown
              u.status = discovered
              u.parent = v
              u.depth = v.depth+1
              Q.Enqueue(u)
           EndIF
        EndFor
     EndWhile 
     

  • What is the performance?
    • This is tougher.
    • How many times will line 8 execute?
    • How about line 11?
    • We know Enqueue and Dequeue are constant.
  • Is it correct?
    • What does this mean?
      • The depth of a node in the BFS tree is the distance from s?
      • All nodes connected to s will be in the BFS tree?
  • By the way, how long will line 11 take?
• After conducting a BFS from s, we can check to see if it is connected to t simply by examining t.distance
  • If this is $\infty$ then it is not connected.