Learning Goals

• Understand graph representations (adjacency list vs matrix).
• Master Breadth-First Search (BFS) algorithm.
• Master Depth-First Search (DFS) algorithm.
• Analyze BFS/DFS complexity and applications.

What is a Graph?

• A Graph $G = (V, E)$ consists of:
• $V$: A set of Vertices (Nodes).
• $E$: A set of Edges (pairs of vertices).
• Fundamental to CS: Social networks, Maps, Internet, Circuitry.

Types of Graphs

• Undirected: Edges are unordered pairs $\{u, v\}$. Relationship is symmetric.
• Directed (Digraph): Edges are ordered pairs $(u, v)$. Arrow from $u$ to $v$.
• Weighted: Edges have a cost/weight $w(u, v)$.

Terminology

• Degree: Number of edges incident to a vertex.
• In-degree vs Out-degree (Directed).
• Path: Sequence of vertices connected by edges.
• Cycle: Path that starts and ends at same node.
• Connected: Path exists between every pair.

Sparse vs Dense

• Let $|V| = n$ and $|E| = m$.
• Max edges (undirected): $\binom{n}{2} = \Theta(n^2)$.
• Sparse: $m \approx n$ (Tree-like, Road networks).
• Dense: $m \approx n^2$ (Complete graphs).

1. Adjacency Matrix

• 2D Array $A[n][n]$.
• $A[i][j] = 1$ if edge $(i,j)$ exists, else 0.
• Pros: $O(1)$ edge check.
• Cons: $O(n^2)$ space. Iterate neighbors takes $O(n)$.

2. Adjacency List

• Array of Lists. $Adj[u]$ contains list of neighbors.
• Pros: Space $O(V + E)$. Iterate neighbors $O(deg(u))$.
• Cons: Check edge takes $O(deg(u))$.
• Verdict: We use Lists for most algorithms (assuming sparse).

Intuition

• Explore layer by layer.
• Like a ripple in a pond.
• Start at source s.
• Visit neighbors of s (Distance 1).
• Visit neighbors of neighbors (Distance 2).

BFS(G, s)

for each u in V - {s}
  d[u] = infinity
  pi[u] = NIL
d[s] = 0
Q = {s} // FIFO Queue
while Q is not empty
  u = Dequeue(Q)
  for each v in Adj[u]
    if d[v] == infinity
      d[v] = d[u] + 1
      pi[v] = u
      Enqueue(Q, v)

BFS Properties

• Use a Queue (FIFO).
• Computes Shortest Path (in terms of # edges) from s to all reachable nodes.
• Generates a BFS Tree (defined by $\pi$ pointers).

BFS Analysis

• Vertex enqueued at most once.
• Dequeued at most once.
• Adjacency list of each vertex scanned once.
• Total time: $\sum_{v} deg(v) = 2E$ (Undirected) or $E$ (Directed).
• Complexity: $O(V + E)$.

Intuition

• Explore as deep as possible.
• Like a maze solver (Right hand rule).
• Backtrack when stuck.
• Uses a Stack (Recursion).

DFS(G)

for each u in V
  color[u] = WHITE
  pi[u] = NIL
time = 0
for each u in V
  if color[u] == WHITE
    DFS-Visit(u)

DFS-Visit(u)

time = time + 1
d[u] = time  // Discovery Time
color[u] = GRAY
for each v in Adj[u]
  if color[v] == WHITE
    pi[v] = u
    DFS-Visit(v)
color[u] = BLACK
time = time + 1
f[u] = time // Finish Time

Timestamps

• Discovery Time $d[u]$: When turned Gray.
• Finish Time $f[u]$: When turned Black (backtracked).
• These timestamps are crucial for many apps (Topological Sort).

Parenthesis Theorem

• Represent interval $[d[u], f[u]]$ is lifetime of u on stack.
• For any two vertices $u, v$, exactly one holds:
• 1. Intervals disjoint (Disjoint subtrees).
• 2. Interval u contains v (u is ancestor of v).
• 3. Interval v contains u (v is ancestor of u).

Classification of Edges

• DFS allows us to classify edges:
• Tree Edge: Visit new white node (recursive call).
• Back Edge: Edge to an ancestor (Gray). Implies Cycle!
• Forward Edge: Edge to descendant (Black).
• Cross Edge: Edge to other branch (Black).

Cycle Detection

• A graph has a cycle iff DFS finds a Back Edge.
• Easy verify for DAG (Directed Acyclic Graph).

Comparison

• BFS:
• Queue.
• Finds shortest paths (unweighted).
• "Wide" tree.
• DFS:
• Stack.
• Does NOT find shortest paths.
• "Deep" tree.
• Good for connectivity, topology, logic.

Connected Components

• Use BFS or DFS.
• Start loop over all V.
• Each call outlines one component.
• Count calls.

Bipartite Checking

• Can we color graph Red/Blue?
• BFS logic:
• Node u is Red $\implies$ Neighbors Blue.
• If see edge Red-Red, impossible.
• BFS handles this naturally (Odd cycles).

Problem 1

• Run BFS on graph below starting at A.
• A -> B, C.
• Queue: [B, C]. Dist 1.
• Pop B. Add D.
• Pop C. Add E.
• Resulting Dists: A:0, B:1, C:1, D:2, E:2.

Problem 2

• Adjacency Matrix Squared?
• If $A$ is adj matrix, what is $A^2$?
• $(A^2)_{ij} = \sum A_{ik} A_{kj}$.
• This counts paths of length exactly 2 from i to j.
• $A^k$ counts paths of length k.

Problem 3

• Diameter of Graph.
• Max shortest path between any pair.
• Algorithm: Run BFS from every node? $O(V(V+E))$.
• Floyd-Warshall (Later) $O(V^3)$.

Watch Out For...

• Using BFS on weighted graphs (use Dijkstra instead).
• Forgetting to mark nodes as visited before enqueueing (causes duplicates).
• Confusing BFS tree depth with DFS timestamps.
• Not handling disconnected components (need outer loop).

BFS vs DFS Visualization

🚀 Interactive Demo: bfs_dfs_demo.html

Activity 1: BFS Trace

• ❓ Problem:
• Run BFS from A: A→{B,C}, B→{D}, C→{D,E}, D→{}, E→{}
• Take 2 minutes to trace the order.

Solution 1

• 💡 Answer:
• Queue: [A] → [B,C] → [C,D] → [D,E] → [E].
• Order: A, B, C, D, E. Distances: A:0, B:1, C:1, D:2, E:2.

Activity 2: DFS Timestamps

• ❓ Problem:
• Run DFS from A: A→{B,C}, B→{D}, C→{}, D→{C}
• Take 3 minutes to record discovery/finish times.

Solution 2

• 💡 Answer:
• A: d=1, f=8. B: d=2, f=7. D: d=3, f=6. C: d=4, f=5.
• Note: C discovered via D, not directly from A.

Activity 3: Edge Classification

• ❓ Problem:
• In DFS, edge (D→C) above — what type?
• Take 1 minute to classify.

Solution 3

• 💡 Answer:
• When D visits C, C is WHITE → Tree Edge.
• If C were GRAY → Back Edge (cycle). BLACK → Forward/Cross.

Activity 4: Bipartite Check

• ❓ Problem:
• Is this graph bipartite? A-B, B-C, C-D, D-A, A-C
• Take 2 minutes to solve using BFS coloring.

Solution 4

• 💡 Answer:
• Color A=Red, B=Blue, C=Red, D=Blue.
• Edge A-C: both Red → Not bipartite (odd cycle A-B-C-A).

Lecture Summary

• Graphs $G=(V,E)$ model pairwise relationships (social, maps, circuits).
• Adjacency List is preferred for sparse graphs: $O(V+E)$ space.
• BFS uses a queue, finds shortest paths, runs in $O(V+E)$.
• DFS uses a stack/recursion, provides timestamps for topology.
• Edge classification (Tree/Back/Forward/Cross) enables cycle detection.

All Interactive Demos

🚀 Interactive Demo: bfs_dfs_demo.html

Supplementary Resources

🚀 Interactive Demo: worked_examples.html
🚀 Interactive Demo: reading_practice.html
🚀 Interactive Demo: handout.html