CSCE 210 Data Structures and Algorithms

1
CSCE 210Data Structures and Algorithms

• Prof. Amr Goneid
• AUC
• Part 10. Graphs

2
Graphs

3
Graphs

• Basic Definitions
• Paths and Cycles
• Connectivity
• Other Properties
• Representation
• Examples of Graph Algorithms
• Graph Traversal
• Shortest Paths
• Minimum Cost Spanning Trees

4
1. Basic Definitions

• A graph G (V,E) can be defined
• as a pair (V,E) , where V is a set
• of vertices, and E is a set of
• edges between the vertices
• E (u,v) u, v ? V. e.g.
• V A,B,C,D,E,F,G
• E ( A,B),(A,F),(B,C),(C,G),(D,E),(D,G),(E,F),(F
  ,G)
• If no weights are associated with the edges, an
  edge is
• either present(1) or absent (0).

5
Basic Definitions

• A graph is like a road map. Cities are vertices.
  Roads from city to city are edges.
• You could consider junctions to be vertices, too.
  If you don't want to count them as vertices, a
  road may connect more than two cities. So
  strictly speaking you have hyperedges in a
  hypergraph.
• If you want to allow more than one road between
  each pair of cities, you have a multigraph,
  instead.

6
Basic Definitions

• Adjacency If vertices u,v have
• an edge e (u,v) u, v ? V then
• u and v are adjacent.
• A weighted graph has a weight
• associated with each edge.
• Undirected Graph is a graph in which the
  adjacency is
• symmetric, i.e., e (u,v) (v,u)
• A Sub-Graph has a subset of the vertices and the
• edges

3
2
2
1
5
4
2
1
7
Basic Definitions
3

• Directed Graph is a graph in which
• adjacency is not symmetric,
• i.e., (u,v) ? (v,u)
• Such graphs are also called
• Digraphs
• Directed Weighted Graph
• A directed graph with a weight
• for each edge. Also called a network.

2
2
1
5
4
2
1
8
2. Paths Cycles

• Path A list of vertices of a graph where each
  vertex
• has an edge from it to the next vertex.
• Simple Path A path that repeats no vertex.
• Cycle A path that starts and ends at the same
  vertex
• and includes other vertices at most once.

9
Directed Acyclic Graph (DAG)

• Directed Acyclic Graph (DAG) A directed graph
  with
• no path that starts and ends at the same vertex

10
Hamiltonian Cycle

• Hamiltonian Cycle
• A cycle that includes all other vertices only
  once,
• e.g. D,B,C,G,A,F,E,D
• Named after Sir William Rowan Hamilton (1805
  1865)
• The Knights Tour problem is a Hamiltonian cycle
  problem

Icosian Game
11
Hamiltonian Cycle Demo

• A Hamiltonian Cycle is a cycle that visits each
  node exactly once. Here we show a Hamiltonian
  cycle on a 5-dimensional hypercube. It starts by
  completely traversing the 4-dimensional hypercube
  on the left before reversing the traversal on the
  right subcube.
• Hamiltonian cycles on hypercubes provide
  constructions for Gray codes orderings of all
  subsets of n items such that neighboring subsets
  differ in exactly one element.
• Hamilitonian cycle is an NP-complete problem, so
  no worst-case efficient algorithm exists to find
  such a cycle.
• In practice, we can find Hamiltonian cycles in
  modest-sized graphs by using backtracking with
  clever pruning to reduce the search space.

12
Hamiltonian Cycle Demo

• http//www.cs.sunysb.edu/skiena/combinatorica/an
  imations/ham.html
• Hamiltonian Cycle Demo

13
Euler Circuit

• Leonhard Euler Konigsberg Bridges
• (1736) (not
  Eulerian)
• Euler Circuit
• A cycle that includes every edge once.
• Used in bioinformatics to reconstruct the DNA
  sequence from its fragments

14
Euler Circuit Demo

• An Euler circuit in a graph is a
• traversal of all the edges of the
• graph that visits each edge
• exactly once before returning
• home. A graph has an Euler circuit
• if and only if all its vertices are that
• of even degrees.
• It is amusing to watch as the Euler circuit finds
  a way back home to a seemingly blocked off start
  vertex. We are allowed (indeed required) to visit
  vertices multiple times in an Eulerian cycle, but
  not edges.

15
Euler Circuit Demo

• http//www.cs.sunysb.edu/skiena/combinatorica/ani
  mations/euler.html
• Euler Circuit Demo

16
3. Connectivity

• Connected Graph An undirected graph with a path
• from every vertex to every other vertex
• A Disconnected Graph may have several connected
• components
• Tree A connected Acyclic graph

17
Connected Components Demo

• What happens when you start with an empty graph
  and add random edges between vertices?
• As you add more and more edges, the number of
  connected components in the graph can be expected
  to drop, until finally the graph is connected.
• An important result from the theory of random
  graphs states that such graphs very quickly
  develop a single giant'' component which
  eventually absorbs all the vertices.

18
Connected Components Demo

• http//www.cs.sunysb.edu/skiena/combinatorica/ani
  mations/concomp.html
• Randomly Connected Graph Demo

19
Connectivity

• Articulation Vertex if removed with all of its
  edges will
• cause a connected graph to be disconnected, e.g.,
  G
• and D are articulation vertices

20
Connectivity

• Degree Of a vertex,
• the number of edges connected to
• it.
• Degree Of a graph,
• the maximum degree of any vertex
• (e.g. B has degree 2, graph has degree 3).
• In a connected graph the sum of the degrees is
  twice
• the number of edges, i.e

21
Connectivity

• In-Degree/Out-Degree the number of edges coming
• into/emerging from a vertex in a connected graph
  (e.g.
• G has in-degree 3 and out-degree 1).

22
Connectivity

• Complete Graph
• There is an edge between
• every vertex and every
• other vertex. In this case,
• the number of edges is
• maximum
• Notice that the minimum number of edges for a
• connected graph ( a tree in this case) is (V-1)

23
Density (of edges)

• Density of a Graph
• Dense Graph
• Number of edges is close to Emax V(V-1)/2.
• So, E ?(V2) and D is close to 1
• Sparse Graph
• Number of edges is close to Emin (V-1).
• So, E O(V)

24
4. Other Properties

• Planar Graph
• A graph that can be drawn in
• the plain without edges
• crossing

Non-Planar
25
Other Properties

• Graph Coloring
• To assign color (or any distinctive mark) to
  vertices
• such that no two adjacent vertices have the same
  color.
• The minimum number of colors needed is called the
• Chromatic Order of the graph ?(G).
• For a complete graph, ?(G) V.

2
1
3
4
26
Other Properties

• An Application
• Find the number of exam slots for 5 courses. If a
  single
• student attends two courses, an edge exists
  between them.

EE
Slot Courses
1 (red) CS
2 (Green) EE, Econ, Phys
3 (Blue) Math
CS
Math
Phys
Econ
27
5. Representation

• Adjacency Matrix
• V x V Matrix a(i,j)
• a(i,j) 1 if vertices (i) and (j) are adjacent,
  zero otherwise. Usually self loops are not
  allowed so that a(i,i) 0.
• For undirected graphs, a(i,j) a(j,i)
• For weighted graphs, a(i,j) wij

A B C D
A 0 1 1 0
B 1 0 1 0
C 1 1 0 1
D 0 0 1 0
28
Representation

• The adjacency matrix is appropriate for dense
  graphs
• but not compact for sparse graphs.
• e.g., for a lattice graph, the degree
• of a vertex is 4, so that E 4V.
• Number of 1s to total matrix size
• is approximately 2 E / V2 8 / V.
• For V gtgt 8, the matrix is dominated by zeros.

29
Representation

• Adjacency List
• An array of vertices with pointers
• to linked lists of adjacent nodes, e.g.,
• The size is O(E V) so it is compact for sparse
  graphs.

B
A
C
B
A
C
C
A
B
D
D
C
30
6. Examples of Graph Algorithms

• Examples of Graph Algorithms
• Graph Traversal
• Shortest Paths
• Minimum Cost Spanning Trees

31
6.1 Graph TraversalDepth-First Search (DFS)

• Visits every node in the graph by following node
  connections in depth.
• Recursive algorithm.
• An Array valv records the order in which
  vertices are visited. Initialized to unseen.
• Any edge to a vertex that has not been seen is
  followed via the recursive call.

32
Algorithm

• // Assume order 0 initially
• void DFS()
• int k int unseen -2
• // Initialize all to unseen
• for (k 1 k lt v k) valk unseen
• // Follow Nodes in Depth
• for (k 1 k lt v k)
• if (valk unseen) visit(k)

33
Algorithm (continued)

• void visit(int k)
• int t
• valk order
• for (t 1 t lt v t)
• if (akt ! 0)
• if (valt unseen) visit(t)

34
Example
1

A
start
B
C
G
F
D
E
A B C D E F G
1
VALK
35
Example
1

A
B
C
G
F
2
D
E
A B C D E F G
1 2
VALK
36
Example
1

A
B
C
G
F
3
2
D
E
A B C D E F G
1 2 3
VALK
37
Example
1

A
B
C
G
F
4
3
2
D
E
A B C D E F G
1 2 3 4
VALK
38
Example
1

A
B
C
G
F
4
3
2
D
E
5
A B C D E F G
1 2 3 5 4
VALK
39
Example
1

A
B
C
G
F
4
3
2
D
E
5
6
A B C D E F G
1 2 3 5 6 4
VALK
40
Example
1

A
7
B
C
G
F
4
3
2
D
E
5
6
A B C D E F G
1 2 3 5 6 4 7
VALK
41
Exercises

• Show how DFS can be used to determine the number
  of connected components in a graph.
• Explore the non-recursive version of the DFS
  using a stack. What will happen if you use a
  queue instead of the stack?

42
Non-Recursive DFS

• // Assume unseen -2 and hold -1
• // Val is set to unseen initially , order
  0
• Stactltintgt S // A stack of integers
• void DFS(int k)
• int t S.push(k)
• while (! S.stackIsEmpty())
• S.pop(k) valk order
• for (t v t gt 1 t--) // Scan from right to
  left
• if (akt ! 0) if (valt unseen)
• S.push(t) valt hold

43
Breadth-First Search (BFS)

• // Replacing the stack by a queue, gives the BFS
  algorithm
• Queuetltintgt Q // A queue of integers
• void BFS(int k)
• int t Q.enqueue(k)
• while (! Q.queueIsEmpty())
• Q.dequeue(k) valk order
• for (t 1 t lt v t) // Scan from left to
  right
• if (akt ! 0) if (valt unseen)
• Q.enqueue(t) valt hold

44
Example BFS

1
A
B
C
G
F
4
5
3
2
D
E
6
7
A B C D E F G
1 5 3 6 7 4 5
45
DFS and BFS of a Tree

• For a tree structure
• DFS is equivalent to Pre-order traversal
• BFS is equivalent to Level-order traversal
• DFS Demo
• BFS Demo

46
Graph Traversal Demos

• http//www.cs.sunysb.edu/skiena/combinatorica/ani
  mations/search.html
• http//www.cosc.canterbury.ac.nz/people/mukundan/d
  sal/GraphAppl.html

47
Exercise
in

• Model the shown maze
• as a graph.
• Show how DFS can be
• used to find the exit.

out
48
8. A Simple Graph Class

• To represent a weighted undirected graph with a
  maximum of Vmax vertices and Emax
  Vmax(Vmax-1)/2 edges. The verices are numbered
  0,1,...V-1.
• The graph is assumed to be on a text file in the
  form of an adjacency matrix. The weights on the
  edges are assumed to be positive integers with
  zero weight indicating the absence of an edge.
• When loaded from the text file, the weights are
  stored in a 2-D array (AdjMatrix) representing
  the adjacency matrix. Another array (edges)
  stores the non-zero edges in the graph.
• An edge (u,v,w) existing between nodes (u) and
  (v) with weight (w) is modeled as a class (Edge).
  

49
Edge Class

• // File Edge.h
• // Definition of Edge class
• ifndef EDGE_H
• define EDGE_H
• typedef int weightType // weights are positive
  integers
• class Edge
• public
• int u,v weightType w
• bool operator lt (const Edge e) return
  (w lt e.w)
• bool operator lt (const Edge e) return (w
  lt e.w)
• // end of class Edge declaration
• endif // EDGE_H

50
Graph Class

• // File Graphs.h
• // Graph library header file
• ifndef GRAPHS_H
• define GRAPHS_H
• include ltstringgt
• include "Edge.h"
• using namespace std
• const int Vmax 50 // Maximum number of
  vertices
• const int Emax Vmax(Vmax-1)/2 // Maximum
  number of edges

51
Graph Class

• class Graphs
• public
• Graphs() // Constructor
• Graphs() // Destructor
• // Map vertex number to a name (character)
• char Vname(const int s) const
• void getGraph(string fname) // Get Graph from
  text File (fname)
• void dispGraph( ) const // Display Ajacency
  Matrix
• int No_of_Verices( ) const // Get number of
  vertices (V)
• int No_of_Edges( ) const // Get Number of
  Non-zero edges (E)
• void dispEdges( ) const // Display Graph edges
• void DFS( ) // Depth First Search Traversal
  (DFS)

52
Graph Class

• private
• int V, E // No.of vertices (V) and edges (E)
• weightType AdjMatrixVmaxVmax // Adjacency
  Matrix
• Edge edgesEmax // Array of non-zero edges
• int order // Order of Visit of a node in the
  DFS
• int valVmax // Array holding order of
  traversal void getEdges() // Get edges from
  adjacency matrix
• void printEdge(Edge e) const // Output an edge
  (e)
• void visit(int k) // Node Visit Function for
  DFS
• endif // GRAPHS_H
• include "Graphs.cpp"

53
6.2 Shortest Paths(General)

• In a graph G(V,E), find shortest paths from a
  single source vertex (S) to all other vertices.
• Edsger Dijkstra published an algorithm to solve
  this problem in 1959.

54
Shortest Paths Dijkstras Algorithm

• Dijkstras Algorithm for V vertices
• Uses three arrays
• - Distancei holds distance from (S) to
• vertex (i).
• - Processedi to flag processed vertices.
• - Viai holds index of vertex from which we
• can directly reach vertex (i).

55
Initialization

• Distancei
• 0 if S i
• Wsi if (S, i) are adjacent
• ? otherwise
• Processedi yes if i S , No otherwise
• Viai S if (i , S) are adjacent, 0 otherwise

56
Method

closest to S
not yet processed
j
Distancej
Already Processed
Wij
S
i
Distancei
x
z
y
adjacent to j
57
Dijkstras Algorithm

• Repeat
• Find j index of unprocessed node closest to (S)
• Mark (j) as now processed
• For each node (i) not yet processed
• if (i) is adjacent to (j) then
• new_distance Distancej Wij
• if new_distance lt Distancei then
• Distancei new_distance
• Viai j
• Until all vertices are processed

58
Example

• Initial Source A

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
59
Example

• j B

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
60
Example

• j B i D

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
61
Example

• j E

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
62
Example

• j E i C

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
63
Example

• j C

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
64
Example

• j C i D

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
65
Example

• j D

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
C
D
35
66
Example

• Final

D
A
C
B
E
Dist
A
15
20
B
Processed
E
35
Via
40
10
A?B A?E?C A?B?D A?E
C
D
35
67
How to print the path?

• / The function Vname(k) maps a vertex number to
  a name (e.g a character A, B,.. etc). Given the
  via array resulting from Dijkstras algorithm,
  the following recursive function prints the
  vertices on the shortest path from source (s) to
  destination (i).
• /
• void GraphsprintPath(int s, int i) const
• if (i s) cout ltlt Vname(s)
• else
• printPath(s,viai) cout ltlt Vname(i)

68
Demo

• http//www.cs.sunysb.edu/skiena/combinatorica/ani
  mations/dijkstra.html
• Shortest Paths Demo1
• Shortest Paths Demo2

69
6.3 Minimum Cost Spanning Trees (a) Spanning Tree

• Consider a connected undirected graph G(V,E). A
  sub-graph S(V,T) is a spanning tree of the graph
  (G) if
• V(S) V(G) and T ? E
• S is a tree, i.e., S is connected and has no
  cycles

70
Spanning Tree

71
Spanning Tree

72
One Graph, Several Spanning Trees

73
Spanning Forest

74
(b) Minimum Cost Spanning Tree(MST)

• Consider houses A..F connected by
• muddy roads with the distances
• indicated. We want to pave some
• roads such that
• We can reach a house from
• any other house via paved roads.
• The cost of paving is minimum.
• This problem is an example of
• finding a Minimum Spanning Tree
• (MST)

4
G
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
75
Minimum Spanning Tree(MST)

• Cost
• For a weighted graph,
• the cost of a spanning tree
• is the sum of the weights
• of the edges in that tree.
• Minimum Spanning tree
• A spanning tree of minimum cost
• For the shown graph, the
• minimum cost is 22

G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
76
Kruskals Algorithm for MST

• The algorithm was written by
• Joseph Kruskal in 1956
• A Greedy Algorithm
• Builds the MST edge by edge into a set of edges
  (T). At a given stage, chooses an edge that
  results in minimum increase in the sum of costs
  included so far in (T).
• The set (T) might not be a tree at all stages of
  the algorithm, but it can be completed into a
  tree iff there are no cycles in (T).

77
Kruskals Algorithm for MST

• Builds up forests , then joins them in a single
  tree.
• Constraints
• - The graph must be connected.
• - Uses exactly V-1 edges.
• - Excludes edges that form a cycle.

78
Abstract Algorithm

• -Form Set E of edges in increasing order of
  costs.
• - Set MST T empty
• -Repeat
• Select an edge (e) from top.
• Delete edge from E set.
• Add edge (e) to (T) if it does not form a cycle,
  otherwise, reject.
• -Until we have V-1 successful edges.

79
Example

Edge u v w accept
1 E F 2
2 A C 3
3 C E 3
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
80
Example

Edge u v w accept
1 E F 2 yes
2 A C 3
3 C E 3
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
81
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
82
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
83
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
84
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
85
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4 yes
7 D F 5
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
86
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4 yes
7 D F 5 No
8 B D 6
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
87
Example

Edge u v w accept
1 E F 2 yes
2 A C 3 yes
3 C E 3 yes
4 A E 4 NO
5 C D 4 yes
6 E G 4 yes
7 D F 5 NO
8 B D 6 yes
G
4
4
E
A
9
2
7
3
3
C
B
F
6
4
5
D
88
How to test for Cycles?Simple Union- Simple Find

• Given a set (1,2,..,n initially partitioned into
  n
• disjoint sets (each element is its own parent)
• Find (i) return the sub-set that (i) is in (i.e.
  return the parent set of i).
• Union (k,j) combine the two sub-sets that (j)
  and (k) are in (make k the child of j)
• Union builds up a tree, while find will search
  for the root of the tree.
• Cost is O(log n)

89
How to test for Cycles?

• Represent vertices as Disjoint Sets
• Initially, each node is its own parent (-1)

A
B
C
D
E
F
G
Let the parent set of u be p(u)
A B C D E F G
1 2 3 4 5 6 7
-1 -1 -1 -1 -1 -1 -1
90
How to test for Cycles?

• When edge (E,F) is selected, we find that p(E) ?
  p(F). So, we make a union between p(E) and p(F),
  i.e., p(F) becomes the child of p(E). Same for
  edge (A,C)

A
B
C
D
E
F
G
Parent table after selecting (E,F) then (A,C)
A B C D E F G
1 2 3 4 5 6 7
-1 -1 1 -1 -1 5 -1
91
How to test for Cycles?

• When (C,E) is selected, we find that P(C) ? P(E).
  This means that the edge will be accepted.
• Select (A,E), Find will give P(A) P(E) (cycle,
  reject).

D
A
E
F
G
B
C
Parent table after accepting (E,F) then (A,C),
then (C,E), then rejecting (A,E)
A B C D E F G
1 2 3 4 5 6 7
-1 -1 1 -1 3 5 -1
92
How to test for Cycles?

• When (C,D) is selected, we find that P(C) ? P(D).
  This means that the edge will be accepted.
• Select (E,G), Find will give P(E) ? P(G)
  (accept).

G
D
A
E
F
B
C
A B C D E F G
1 2 3 4 5 6 7
-1 -1 1 3 3 5 5
Parent table after 5th accepted edge
93
How to test for Cycles?

• When (D,F) is selected, we find that P(D) P(F).
  This means that the edge will be rejected.
• Select (B,D), Find will give P(B) ? P(D)
  (accept).

G
D
A
E
F
B
C
A B C D E F G
1 2 3 4 5 6 7
-1 4 1 3 3 5 5
Parent table after 6th accepted edge (Final MST)
94
Kruskals Algorithm

• Insert edges with weights into a minimum heap
• Put each vertex in a separate set
• i 0
• While ((i lt V-1) (heap not empty))
• Remove edge (u,v) from heap
• Find set (j) of connected vertices having (u)
• Find set (k) of connected vertices having (v)
• if ( j ! k )
• i MST i.u u MST i.v v
• MST i.w w
• Make a Union between set (j) and set (k)

95
Kruskals Algorithm Demo

• http//www.cs.sunysb.edu/skiena/combinatorica/an
  imations/mst.html
• Kruskal's algorithm at work on a graph of
  distances between 128 North American cities.
  Almost imperceptively at first, short edges get
  added all around the continent, slowly building
  forests until the tree is completed.
• MST (Kruskal) Demo1
• MST (Kruskal) Demo2

96
Learn on your own about

• Directed Graphs or Digraphs
• Edge-List representation of graphs
• Prims algorithm for Minimum Spanning Trees. The
  algorithm was developed in 1930 by Czech
  mathematician Vojtech Jarník
• and later independently by
• computer scientist
• Robert C. Prim in 1957
• and rediscovered by
• Edsger Dijkstra in 1959. Therefore it is also
  sometimes called the DJP algorithm, the Jarník
  algorithm, or the PrimJarník algorithm.