1. Discrete Mathematics and
Graph
Discrete Mathematics and
Its Applications
Baojian Hua

2. What’s a Graph?
Graph: a group of vertices connected by edges

3. Why Study Graphs? Interesting & broadly used abstraction
not only in computer science
challenge branch in discrete math
Ex: the 4-color problem
hundreds of known algorithms
with more to study
numerous applications

4. Broad Applications Graph Vertices Edges communication telephone cables
software
functions
calls
internet
web page
hyper-links
social relationship
people
friendship
transportation
cities
roads …

5. Graph Terminology 1 2 3
vertex
edge:
directed vs
undirected 4 5 6
A sample graph taken from chapter 22 of Introduction to Algorithms.

6. Graph Terminology 1 4 2 6 5 3
degree:
in-degree vs
out-degree

7. Graph ADT A graph is a tuple (V, E) Typical operations:
V is a set of vertices v1, v2, …
E is a set of vertex tuple <vi, vj>
Typical operations:
graph creation
search a vertex (or an edge)
traverse all vertexes …

8. Example G = (V, E) V = {1, 2, 3, 4, 5, 6} E = {(1, 2), (2, 5), (4, 1),
(3, 5),
(3, 6),
(4, 1),
(4, 2),
(5, 4),
(6, 6)} 1 4 2 6 5 3

9. Representation Two popular strategies: array-based (adjacency matrix)
Keep an extensible two-dimensional array M internally
M[i][j] holds the edge info’ of <vi, vj>, if there exists one
linear list-based (adjacency list)
for every vertex vi, maintain a linear list list<vi>
list<vi> stores vi’s outing edges

10. Adjacency Matrix # Note the hash function: hash (n) = n-1 1 4 2 6 5 31 2 3 4 5 # 1 2
Note the hash function:
hash (n) = n-1 3 4 5

11. Adjacency List Notice the pointers! 1 1->2 2 2->5 3 3->5
3->6 4
4->1
4->2 5
5->4
Notice the pointers! 6
6->6

12. Graph in C

13. “graph” ADT in C: Interface
// We assume, in this slides, all graphs directed,
// and undirected ones are similar and easier.
// in file “graph.h”
#ifndef GRAPH_H
#define GRAPH_H
typedef struct graph *graph;
graph newGraph ();
void insertVertex (graph g, poly data);
void insertEdge (graph g, poly from, poly to);
// more to come later …
#endif

14. Graph Implementation #1: Adjacency Matrix
// adjacency matrix-based implementation
#include “matrix.h”
#include “hash.h”
#include “graph.h”
struct graph {
matrix matrix;
// remember the index
hash hash; }; 1 2 3 # 1 2 3

15. Matrix Interface // file “matrix.h” #ifndef MATRIX_H #define MATRIX_H
typedef struct matrix *matrix;
matrix newMatrix ();
void matrixInsert (matrix m, int i, int j);
int matrixExtend (matrix m);
#endif
// Implementation could make use of a two-
// dimensional extensible array, leave to you.

16. Adjacency Matrix-based: Graph Creation
graph newGraph () {
graph g = malloc (sizeof (*g));
g->matrix = newMatrix (); // an empty matrix
g->hash = newHash ();
return g; }

17. Adjacency Matrix-based: Inserting Vertices
void insertVertex (graph g, poly data) {
int i = matrixExtend (g->matrix);
hashInsert (g->hash, data, i);
return; } 1 2 3 4 # 1 2 3 # 1 1 2 2 3 3 4

18. Graph Implementation #1: Inserting Edges
void insertEdge (graph g, poly from, poly to) {
int f = hashLookup (g->hash, from);
int t = hashLookup (g->hash, to);
matrixInsert (g->matrix, f, t);
return; } 1 2 3 4 # 1 2 3 # 1 1 2 2 3 3 4

19. Client Code graph g = newGraph (); insertVertex (g, 1);…
insertVertex (g, 6);
insertEdge (g, 1, 2);
insertEdge (g, 2, 5);
insertEdge (g, 6, 6); 1 4 2 6 5 3

20. Graph Representation #2: Adjacency List
#include “linkedList.h”
#include “graph.h”
struct graph {
linkedList vertices; };
typedef struct vertex *vertex;
typedef struct edge *edge;
struct vertex {
poly data;
linkedList edges;
struct edge {
vertex from;
vertex to; }

21. Graph Representation #2: Adjacency List
#include “linkedList.h”
#include “graph.h”
struct graph {
linkedList vertices; };
typedef struct vertex *vertex;
typedef struct edge *edge;
struct vertex {
poly data;
linkedList edges;
struct edge {
vertex from;
vertex to; } 1 2 3
0->1
0->2
0->3

22. Adjacency List-based: Graph Creation
// I’ll make use of this convention for colors:
// graph, linkedList, data, vertex, edge
graph newGraph () {
graph g = malloc (sizeof (*g));
g->vertices = newLinkedList ();
return g; }
vertices g /\

23. Adjacency List-based: Creating New Vertex
// I’ll make use of this convention for colors:
// graph, linkedList, data, vertex, edge
vertex newVertex (poly data) {
vertex v = malloc (sizeof (*v));
v->data = data;
v->edges = newLinkedList ();
return v; }
data v /\
edges

24. Adjacency List-based: Creating New Edge
// I’ll make use of this convention for colors:
// graph, linkedList, data, vertex, edge
edge newEdge (vertex from, vertex to) {
edge e = malloc (sizeof (*e));
e->from = from;
e->to = to;
return e; }
from e to

25. Adjacency List-based: Inserting New Vertex
void insertVertex (graph g, poly data) {
vertex v = newVertex (data);
linkedListInsertTail (g->vertices, v);
return; } 1 2 3
0->1
0->2
0->3 4

26. Adjacency List-based: Inserting New Vertex
void insertVertex (graph g, poly data) {
vertex v = newVertex (data);
linkedListInsertTail (g->vertices, v);
return; } 1 2 3
0->1
0->2
0->3 4

27. Adjacency List-based: Inserting New Vertex
void insertVertex (graph g, poly data) {
vertex v = newVertex (data);
linkedListInsertTail (g->vertices, v);
return; } 1 2 3
0->1
0->2
0->3 4

28. Adjacency List-based: Inserting New Edge
void insertEdge (graph g, poly from, poly to) {
vertex vf = lookupVertex (g, from);
vertex vt = lookupVertex (g, to);
edge e = newEdge (vf, vt);
linkedListInsertTail (vf->edges, e);
return; }
// insert 0->4 1 2 3
0->1
0->2
0->3 4

29. Adjacency List-based: Inserting New Edge
void insertEdge (graph g, poly from, poly to) {
vertex vf = lookupVertex (g, from);
vertex vt = lookupVertex (g, to);
edge e = newEdge (vf, vt);
linkedListInsertTail (vf->edges, e);
return; } 1 2 3
0->1
0->2
0->3 4

30. Adjacency List-based: Inserting New Edge
void insertEdge (graph g, poly from, poly to) {
vertex vf = lookupVertex (g, from);
vertex vt = lookupVertex (g, to);
edge e = newEdge (vf, vt);
linkedListInsertTail (vf->edges, e);
return; } 1 2 3
0->1
0->2
0->3 4

31. Adjacency List-based: Inserting New Edge
void insertEdge (graph g, poly from, poly to) {
vertex vf = lookupVertex (g, from);
vertex vt = lookupVertex (g, to);
edge e = newEdge (vf, vt);
linkedListInsertTail (vf->edges, e);
return; }
0->1
0->2
0->3
0->4 1 2 3 4

32. Adjacency List-based: Inserting New Edge
void insertEdge (graph g, poly from, poly to) {
vertex vf = lookupVertex (g, from);
vertex vt = lookupVertex (g, to);
edge e = newEdge (vf, vt);
linkedListInsertTail (vf->edges, e);
return; }
0->1
0->2
0->3
0->4 1 2 3 4

33. Example 1 4 2 6 5 3

34. Client Code for This Example: Step #1: Cook Data
str gname = newStr (“test”);
graph graph = newGraph (gname);
nat n1 = newNat (1);
nat n2 = newNat (2);
nat n3 = newNat (3);
nat n4 = newNat (4);
nat n5 = newNat (5);
nat n6 = newNat (6); 1 2 3 4 5 6

35. Client Code Continued: Step #2: Insert Vertices
graphInsertVertex (graph, n1);
graphInsertVertex (graph, n2);
graphInsertVertex (graph, n3);
graphInsertVertex (graph, n4);
graphInsertVertex (graph, n5);
graphInsertVertex (graph, n6); 1 2 3 4 5 6

36. Client Code Continued: Step #3: Insert Edges
graphInsertEdge (graph, n1, n2);
graphInsertEdge (graph, n2, n5);
graphInsertEdge (graph, n3, n5);
graphInsertEdge (graph, n3, n6);
graphInsertEdge (graph, n4, n1);
graphInsertEdge (graph, n4, n2);
graphInsertEdge (graph, n5, n4);
graphInsertEdge (graph, n6, n6);
// Done! :-) 1 2 3 4 5 6

37. Example In Picture: An Empty Graph
// I’ll make use of this convention for colors:
// graph, linkedList, data, vertex, edge g
next
data

38. Example In Picture: After Inserting all Vertices
// I’ll make use of this convention for colors:
// graph, linkedList, data, vertex, edge g
next /\
data 1 5 6 2 3 4
data
next /\ /\ /\ /\ /\

39. Example In Picture: After Inserting all Edges (Part)
// I’ll make use of this convention for colors:
// graph, linkedList, data, vertex, edge g
next /\
data 1 5 6 2 3 4
data
next /\ /\ /\ /\
from
from to to /\ /\

40. Graph Traversal

41. Searching The systematic way to traverse all vertex in a graph
Two general methods:
breath first searching (BFS)
start from one vertex, first visit all the adjacency vertices
depth first searching (DFS)
eager method
These slides assume the adjacency list representation

42. “graph” ADT in C: Interface
// in file “graph.h”
#ifndef GRAPH_H
#define GRAPH_H
typedef struct graph *graph;
typedef void (*tyVisit)(poly);
graph newGraph ();
void insertVertex (graph g, poly data);
void insertEdge (graph g, poly from, poly to);
void dfs (graph g, poly start, tyVisit visit);
void bfs (graph g, poly start, tyVisit visit);
// we’d see more later …
#endif

43. Sample Graph 1 2 3 4 5 6

44. Sample Graph BFS
bfs (g, 1, natOutput); 1 2 3 4 5 6

45. Sample Graph BFS
bfs (g, 1, natOutput);
print 1; 1 2 3 4 5 6

46. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

47. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

48. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

49. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

50. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

51. BFS Algorithm bfs (vertex start, tyVisit visit) {
queue q = newQueue ();
enQueue (q, start);
while (q not empty) {
vertex current = deQueue (q);
visit (current);
for (each adjacent vertex u of “current”){
if (not visited u)
enQueue (q, u); }

52. BFS Algorithm void bfsMain (graph g, poly start, tyVisit visit) {
vertex startV = searchVertex (g, start);
bfs (startV, visit);
for (each vertex u in graph g)
if (not visited u)
bfs (q, u); }

53. Sample Graph BFS
bfs (g, 1, natOutput); 1 2 3 4 5 6
Queue: 1

54. Sample Graph BFS bfs (g, 1, natOutput); print 1; 1 2 3 4 5 6 Queue: 1

55. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
Queue: 1
Queue: 2, 4
Queue: , 5

56. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
Queue: 1
Queue: 2, 4
Queue: , 5
Queue:

57. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
Queue: 1
Queue: 3
Queue: 2, 4
Queue: , 5
Queue:
Queue:

58. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
Queue: 1
Queue: 3
Queue: 2, 4
Queue: , 5
Queue: 6
Queue:
Queue:

59. Sample Graph BFS bfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
Queue: 1
Queue: 3
Queue: 2, 4
Queue: , 5
Queue: 6
Queue:
Queue:
Queue:

60. Moral BFS is very much like the level-order traversal on trees
Maintain internally a queue to control the visit order
Obtain a BFS forest when finished

61. Sample Graph DFS
dfs (g, 1, natOutput); 1 2 3 4 5 6

62. Sample Graph DFS
dfs (g, 1, natOutput);
print 1; 1 2 3 4 5 6

63. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

64. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

65. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

66. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

67. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6

68. DFS Algorithm dfs (vertex start, tyVisit visit) { visit (start);
for (each adjacent vertex u of “start”)
if (not visited u)
dfs (u, visit); }

69. DFS Algorithm void dfsMain (graph g, poly start, tyVisit visit) {
vertex startV = searchVertex (g, start);
dfs (startV, visit);
for (each vertex u in graph g)
if (not visited u)
dfs (u, visit); }

70. Sample Graph DFS
dfs (g, 1, natOutput);
print 1; 1 2 3 4 5 6
dfs(1)

71. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1) => dfs(2)

72. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1) => dfs(2) => dfs(5)

73. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1) => dfs(2) => dfs(5) => dfs(4)

74. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1) => dfs(2) => dfs(5) => dfs(4) => dfs(2)???

75. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1) => dfs(2) => dfs(5)

76. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1) => dfs(2)

77. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1)

78. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1) =>dfs(4)???

79. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(1)

80. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
empty!

81. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3)

82. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3) =>dfs(5)???

83. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3)

84. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3) =>dfs(6)

85. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3) =>dfs(6) =>dfs(6)???

86. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3) =>dfs(6)

87. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3)

88. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
dfs(3)

89. Sample Graph DFS dfs (g, 1, natOutput); print 1; // a choice print 2;3 4 5 6
empty!

90. Moral DFS is very much like the pre-order traversal on trees
Maintain internally a stack to control the visit order
for recursion function, machine maintain an implicit stack
Obtain a DFS forest when finished

91. Edge Classification
Once we obtain the DFS (or BFS) spanning trees (forests), the graph edges could be classified according to the trees:
tree edges: edges in the trees
forward edges: ancestors to descants
back edges: descants to ancestors
cross edges: others

92. Edge Classification Example
tree edges:
1->2, 2->5, 5->4, 3->6
forward edges:
1->4
back edges:
4->2, 6->6
cross edges:
3->5 1 2 3 4 5 6