Chapter 9: Graph Algorithms

Graph Algorithms

G = (V, E)


where, V: set of vertices


E: set of edges (v,w), where $v, w \in V$

Directed graph

(digraph)

• direction associated with edges
• (v,w) is an ordered pair

Adjacency

: w adjacent to v iff $(v,w) \in E$.

Edge weight

: cost associated with edge

Loop

: edge of the form (v,v)

Paths

Sequence of adjacent vertices $w_1,w_2,\ldots,w_n$

Path length

: number of edges on the path.

Simple path

: all vertices (except possibly first and last) are distinct.

Cycle

: w₁=w_n

• path should have at least one edge
• edges are distinct

Acyclic graph

: graph with no cycles.

Graph Connectivity

Connected graph

(undirected): path between every pair of vertices.

Strongly connected graph

: directed graph that is connected.

Weakly connected graph

: directed graph whose underlying graph is connected, and not strongly connected.

Complete graph

: edge between every pair of vertices (clique).

Graph Representation

Adjacency Matrix

: a $V\times V$ matrix representing edges.
Not good for sparse graphs: $O(\mid V \mid^2)$ space

Adjacency List

: list of adjacent vertices for each vertex.
$O(\mid V \mid + \mid E \mid)$ space.

Topological Sort

• ordering of vertices in a directed graph.
• not possible for cyclic graphs.
• if path (v_i,v_j), then v_i appears before v_j.

Procedure

1.

print vertex with no incoming edge

2.

remove printed vertex and all outgoing edges from it

3.

repeat for rest of the graph

4.

Time = $O(\mid V \mid + \mid E \mid)$

Shortest Path Algorithm

Input

: weighted graph, and a vertex S.

Goal

: find shortest weighted path from S to every other vertex.

Negative cost cycle

: cycle weight < 0.
Shortest paths are not defined in this case.

Unweighted Shortest Path

• path length = # of edges on the path
• use breadth first search
• maintain queue
• $O(\mid V \mid + \mid E \mid)$

Weighted Shortest Path

Dijkstra's algorithm

• dequeue known vertex
• update its adjacent vertices (similar to Decrease_key)
• select minimum of explored, but unknown vertices
• mark it as known and enqueue
• repeat the process
• update time = Find_min time = $O(log \mid V\mid)$
  Shortest Path (contd.)
  Graph with negative edge costs
  • concept of known vertices does not work
  • algorithm should be capable of changing its mind about vertices
  • enqueue and dequeue vertices, exploring their adjacent edges until queue is empty
  Acyclic graph
  • select vertices in topological order
  • perform selection and updates as topological sort is performed
  • no need for priority queues
  Network Flow Problem
  • directed graph
  • source S
  • sink T
  • capacity of edge (v,w) = C_v,w
  Goal: Find maximum flow from source to sink
  
  
  Constraint: At intermediate nodes:
  in-flow = out-flow
  Network Flow: Greedy Approach
  Given graph G, create:
  • G_f: flow graph
  • G_r: residual graph

  1.

  add positive flow path between source and sink to G_f

  2.

  subtract corresponding capacity from G_r

  3.

  stop when sink unreachable from source (no path of positive edges)

  May generate suboptimal solutions.
  Network Flow: Improvements
  • the algorithm should be allowed to change its mind (backtrack)
  • for every edge (v,w) with flow f_v,w added to G_f, add an edge (w,v) to G_r with capacity f_v,w
  • same stopping condition
  Leads to optimal solutions
  Minimum Spanning Tree
  • undirected graph
  • connected
  • non-negative weights associated with edges
  Construction Requirements:

  1.

  Tree: acyclic subgraph

  2.

  Spanning: connecting all vertices in the graph

  3.

  Minimum: minimum sum of edge weights

  Number of edges in the tree = $\mid V \mid - 1$
  
  Prim's Algorithm: Minimum Spanning Tree
  Two sets of vertices:
  • 
    vertices already in tree
  • other vertices

  1.

  choose non-tree vertex v with minimum weight edge to any tree vertex

  2.

  add v and corresponding minimum weight edge to tree

  3.

  continue until all vertices accounted for

  
  $O(\mid V \mid^2)$: without heaps $\Rightarrow$ dense graphs $O(\mid E \mid log \mid V \mid)$: heaps $\Rightarrow$ sparse graphs
  Kruskal's Algorithm: Minimum Spanning Tree

  1.

  start with a forest of $\mid V \mid$ trees

  2.

  maintain edge weights in a heap

  3.

  keep adding minimum weight edges that do not form cycle(s)

  Time = $O(\mid E \mid log \mid E \mid)$ = $O(\mid E \mid log \mid V \mid)$
  
  Tree Search Approaches
  Breadth-first search
  • 
    start from root
  • search level by level
  • appropriate data structure: queue
    
  Depth-first search
  • 
    start from root
  • travel to a leaf along a path
  • backtrack one level
  • travel down another branch
  • if all branches of a node explored: backtrack another level
  • continue until all subtrees of root explored
  • appropriate data structure: stack
  Edge Classifications: Tree Traversal
  Undirected Graph
  • Tree edge: connecting a node to its child
  • Back edge: connecting a node to its ancestor
  Directed Graph - two additional types
  • Forward edge: non-tree edge connecting a node to its descendant
  • Cross edge: connecting nodes that are not directly related
  Biconnectivity
  Biconnected graph: graph with no vertex such that its removal disconnects the rest of the graph.
  
  
  Articulation point: vertex whose removal disconnects the graph.
  Detection of Articulation Points
  • depth first search of vertices while numbering them in ascending order: Num(v)
  • determine lowest-numbered vertex reachable from v: Low(v) is minimum of:

    1.

    Num(v)

    2.

    lowest Num(w) among back edges (v,w)

    3.

    lowest Low(w) among tree edges (v,w)

  • if root has more than one child $\Rightarrow$ root is an articulation point
  • for non-root vertex v and its child w, if $Low(w) \geq Num(v)$ $\Rightarrow$ vertex v is an articulation point
  
  $O(\mid E \mid + \mid V \mid)$
  Euler Circuits
  Goal: to find a path in a graph that visits every edge exactly once.
  
  
  
  
  Necessary and sufficient conditions:
  
  
  
  
  Euler circuit: connected graph and every vertex should have an even degree.
  
  
  
  Euler tour: exactly two vertices have odd degree. Visits every edge, but does not return to starting vertex.
  Euler circuit construction
  • construct a circuit
  • repeat:
    • if untraversed edges out of a vertex in circuit:
      • construct a circuit starting at this vertex
      • splice this circuit into previous circuit
  • until all edges traversed
  $O(\mid E \mid + \mid V \mid)$