Graph: representation and traversalCISC4080, Computer Algorithms

CIS, Fordham Univ.

Instructor: X. Zhang

Outline• Graph Definition

• Graph Representation • Path, Cycle, Tree, Connectivity • Graph Traversal Algorithms

• Breath first search/traversal • Depth first search/traversal • …

2

Graph• Graph: a set of nodes (vertices) with edges (links)

between them, G=(V,E), where V is set of vertices, E: set of edges • model binary relation (i.e., whether two elements/

people/cities/courses are related or not) • e.g., WWW: nodes are webpages, edges are

hyperlinks, e.g.,<a href=“www.wikipedia.com”>wiki</a>

3

Graph: application

• Binary relation could be symmetric or asymmetric • Symmetric relation: always go both way

– e.g., for any two people A and B, if A is B’s facebook friend, then B is also A’s facebook friend.

– no need to draw an arrow ==> Undirected graph

• Asymmetric relation: not always go both way – e.g., my web page linked to cnn.com, but not

vice versa – use an arrow to show “direction” of the relation 4

Undirected Graphs

• Undirected Graph: no arrow on edges • each edge can be represented as a set of two

nodes • degree of a node: the # of edges sticking out

of the node

1 2

3 4

5

V={1,2,3,4} E={ {1,2), {1,3}, {2,4}, {2,3}}

degree of node 1: degree of node 4: total degree of all nodes: 8 total number of edges: 4 relation between above two quantities: total degree=2|E|?

Directed Graphs

• Directed Graphs: each edge has an arrow showing the direction of the binary relation

• e.g., 1 is related to 2, but 2 is not related to 1 • each edge is an ordered pair

• Degree of a node • in-degree: number of edges pointing to a node • out-degree: number of edges coming out from a node

1 2

3 4

6

V={1,2,3,4} E={ (1,2), (2,2), (3,1), (2,3), (2,4),(3,4), (4,3)}

in-degree of node 2: 2 out-degree of node 2:3

Outline• Graph Definition

• Graph Representation

• Path, Cycle, Tree, Connectivity

• Graph Traversal Algorithms

• Breath first search/traversal

7

Graph Representation• How to store a graph, G=(V,E) in computer

program? • V: the set of nodes, can be stored in a vector or an

array of nodes • E: the set of edges (adjacency relation between

nodes) can be stored as • adjacency list, or • adjacency matrix

8

Adjacency list, G=(V,E)• For each node u, maintain a list Adj[u] (adjacency list) which stores all vertices v such that there is an edge from u to v

• Organize adjacency lists into an array • Can be used for both directed and undirected graphs

1 2

5 4

3

2 5 /

1 5 3 4 /

1

2

3

4

5

2 4

2 5 3 /

4 1 2Undirected graph

9

Adj

Properties of Adjacency List Representation

• Memory required

– Θ(|V|+|E|)

• Advantage: save memory when graph is sparse, i.e., |E| << |V|2

• Disadvantage

• to determine whether there is an edge between node u and v, need to

traverse adj[u], with time O(out-degree(u))

• Time to list all vertices adjacent to u: Θ(out-degree(u))

10

Adjacency matrix representation• Assume nodes are numbered 1, 2, … n, n=|V| • Represent E using a matrix Anxn aij = 1 if (i, j) belongs to E, i.e., if there is edge (i,j) 0 otherwise

1 2

5 4

3

Undirected graph

1

2

3

4

5

1 2 3 4 5

0 1 10 0

1 1 1 10

1 10 0 0

1 1 10 0

1 1 10 0

For undirected graphs, matrix A is symmetric: aij = aji for any i,j A = AT

11

aij is the i-th rown, j-th column in the matrix A

Properties of Adjacency Matrix • Memory required

– Θ(|V|2), independent of number of edges in G

• Preferred when – graph is dense: |E| is close to |V|2 – need to quickly determine if there is an edge between

two vertices

• Time to list all vertices adjacent to u: – Θ(n)

• Time to determine if (u, v) belongs to E: – Θ(1)

12

Weighted Graphs• Weighted graphs: in which each edge has an

associated weight w(u, v) (a real number) – you can think of w as a function that maps each edge

to a real value (indicating cost of traversing the edge, e.g.)

• w: E -> R, weight function • Storing weights of a graph

– Adjacency list: • Store w(u,v) along with vertex v in u’s adjacency list

– Adjacency matrix: • Store w(u, v) at location (u, v) in the matrix

13

Outline• Graph Definition

• Graph Representation • Path, Cycle, Tree, Connectivity • Graph Traversal Algorithms

• BFS

14

Paths• A Path in a graph G=(V,E) is a sequence of nodes v1,v2,

…,vk , where each and every consecutive pair vi-1, vi is

joined by an edge in E, i.e., (vi-1, vi) is an edge

• Length of a path: number of edges traversed by the path

15

1 2

3 4

1 2

3 4is1,3,2 a path in G1?

Is1,2,3,4 a path in G1; no, ..

Are these paths?

1,2,3: path, l=2

1,2,3,1,2,4: path, 5

1,2,3,1: yes

1,3,2: not a path

G1

G2

Simple Path• A path is simple if all nodes in the path are distinct.

• i.e., we don’t revisit a node…

• A cycle is a path v1,v2,…,vk where v1=vk, k>2, and the

first k-1 nodes are all distinct

• Which one is simple path? which one is cycle?

16

1 2

3 4

1 2

3 41,3,2

1,2,3,4

1, 2, 3, 1, 2

1,2,3: simple path

1,2,3,1,2,4: not simple

1,2,3,1: not simple, cycle.

1,3,2

G1G2

Shortest (hop) Paths• There are often times multiple paths from u to v.

• Shortest path from u to v is a path from u to v, with distance

that is smaller than or equal to all other paths from u to v

• Shortest path from u to v is always a simple path.17

1 2

3 4

All paths from 1 to 4?

1) 1,3, 2, 4: length of path is

2) 1, 2, 4 <— shortest(-hop) path from 1 to 4

We say node 4 is 2-hop away from Node 1.

2 is the predecessor node for node 4

3) 1, 3, 2, 1, 2, 4

…. There are infinite!

Exercise• For G=(V,E), where V={1,2,3,4,5,6}, with following

adjacency matrix: • Is it directed? undirected? Why? • Is 2,3,4,5,6 a path? Why?

18

Directed or undirected=> is the matrix symmetric along main diagonal line?

Undirected graph

Is a_23 a_34 a_45 a_56

Exercise• A graph is connected if and only if

• for any two nodes u, v, there is a path connecting u to v.

• For G=(V,E), V={1,2,3,4,5,6}, with following adjacency matrix: • First draw graph, then decide whether it is connected.

19

Outline• Graph Definition

• Graph Representation • Path, Cycle, Connectivity • Graph Traversal Algorithms

• basis of other algorithms

20

• Graph traversal: starting from one node initially, visit other nodes by following edges of graph in a systematic way

• Two basic graph traversal algorithms: – Breadth-first search – Depth-first search

– They differ in the order in which they explore unvisited edges of the graph

Traversing a Graph

21

Breadth-First Search (BFS)• Given a graph G = (V, E) , a source node s from V

• Follow edges of G to “discover” every node reachable from s • first follow edges from s to discover all nodes that are one-hop

away from s • from these one-hop away nodes, discover nodes that are two-hop

away from s, …, • …, from k-hop away nodes, discover nodes that are k+1-hop away … • until all reachable nodes have been visited

• Example: starting from source node 1, list nodes that are one-hop, two-hop away from node 1?

22

1 2

5 4

3

S=1

Nodes Coloring: avoid revisit • When exploring node 2’s neighboring nodes, we re-

discover node 1.

• we will be stuck in a loop

• Solution: use color to represent node state

– White: not yet discovered – Gray: discovered, but not explored yet (i.e., we haven’t

explored its neighboring nodes yet) – Black: discovered, and explored

Node 1 would be Black when we explore node 2

source 1 2

5 4

3

23

FIFO Queue: all gray nodes • How to maintain all grey nodes, i.e., discovered and yet to be

explored? • Observation: in BFS, Discover nodes with smaller hop count

first, and explore nodes with smaller hop count first • Solution: enqueue nodes when they are discovered, and

dequeue them one by one to explore

Example, FIFO queue Q • First, source node is discovered, Q=1 • Remove 1 from Q, explores its neighbors, Q=3, 2 • Remove 3 from Q, explores its neighbors,

Q=2, 5, 6 Q = 5, 6, 4

source

24

Breadth First Traversal: how to 1. Initially, all nodes are white

2. source node s is discovered first, color it gray, and insert it into a FIFO queue, Q

3. Take next node u from queue Q,

• follow edges coming out from u to discover all its adjacent white nodes, color them gray, insert to Q

• color u black

4. Go back to 3, until Q is empty

1 2

5 4

3

1 2

5 4

3

source

1 2

5 4

3

25

step 1 step 2 after step 3

1 2

5 4

3

start step 3

Q: 1 Q: 2, 5 Q: 5

1. Initially, all nodes are white

2. source node s is discovered first, color it gray, and insert it into a FIFO queue, Q

3. Take next node u from queue Q,

• follow edges coming out from u to discover all its adjacent white nodes,

• for each of these node, v, insert it to Q • color[v] = gray • set d[v]=d[u]+1 • set pred[v]=u

• color u black

4. Go back to 3, until Q is empty

– d[v]: length of shortest path from s to v

– pred[v]: predecessor node in shortest path from s to v

BFS output

26

1 2

5 4

3

S

d[2]=1 pred[2]=1

d[5]=1 pred[5]=1

d[3]=2 pred[3]=2

d[4]=2 pred[4]=2

d[1]=0 pred[1]=NULL

BFS: Implementation Detail• Three maps/dictionaries:

• color[u] – color of vertex u in V

• pred[u] – predecessor of u

– If u = s (root) or node u has not yet been discovered then

pred[u] = NIL

• d[u] – distance from source s to vertex u

1 2

5 4

3

d=1 pred =1

d=1 pred =1

d=2 pred=5

d=2 pred =2

source

27

BFS(V, E, s): tracing1. BFS( V, E, s)

2. {

3. for each u in V - {s}

4. color[u] = WHITE

5. d[u] ← ∞

6. pred[u] = NIL

5. color[s] = GRAY,

6. d[s] ← 0, pred[s] = NIL

8. Q = empty

9. ENQUEUE(Q, s)

28

10. while Q not empty

11. u ← DEQUEUE(Q)

12. for each v in Adj[u]

13. if color[v] = WHITE

14. color[v] = GRAY

15. d[v] ← d[u] + 1

16. pred[v] = u

17. ENQUEUE(Q, v)

18. color[u] = BLACK

19. }r s t u

v w x y

BFS(V, E, s)1. BFS( V, E, s)

2. {

3. for each u in V - {s}

4. color[u] = WHITE

5. d[u] ← ∞

6. pred[u] = NIL

5. color[s] = GRAY,

6. d[s] ← 0, pred[s] = NIL

8. Q = empty

9. ENQUEUE(Q, s)

29

10. while Q not empty

11. u ← DEQUEUE(Q)

12. for each v in Adj[u]

13. if color[v] = WHITE

14. color[v] = GRAY

15. d[v] ← d[u] + 1

16. pred[v] = u

17. ENQUEUE(Q, v)

18. color[u] = BLACK

19. }

r s t u

v w x y

Suppose BFS(V, E, r) is called , i.e., src node is r label node (d, pred)

a

b

c

Analysis of BFS1. for each u ∈ V - {s}

2. do color[u] ← WHITE

3. d[u] ← ∞

4. pred[u] = NIL 5. color[s] ← GRAY

6. d[s] ← 0

7. pred[s] = NIL 8. Q ← ∅

9. ENQUEUE(Q, s)

O(|V|)

Θ(1)

30

Analysis of BFSScan Adj[u] for all nodes u in graph • Each u is processed only once • Sum of lengths of all adjacency lists = Θ(|E|) •So: while loop has # steps that is O(|E|)

Total running time for BFS:

O(|V| + |E|) 31

10. while Q not empty

11. u ← DEQUEUE(Q)

12. for each v in Adj[u]

13. if color[v] = WHITE

14. then color[v] = GRAY

15. d[v] ← d[u] + 1

16. pred[v] = u

17. ENQUEUE(Q, v)

18. color[u] = BLACK

Property of Breadth-First Traversal

•Node u is reachable from s: there is a path from s to u

•A BFS from source node s discovers all nodes, u, that are reachable from s

•node 6 below won’t be discovered •some nodes might stay white after BFS.

32

1 2

5 4

3

S=1

6

Property of Breadth-First Traversal

• If u is k-hop away from s, then after BFS(G,s) • d[u]=k, • pred[u] is set to pred. node in shortest path s, … ,?, u

• Why? • reason using math. induction on k • true for k=1 (e.g., node 2, 5). • If true for all nodes k-hop away, then also true for K+1-

hop nodes

33

1 2

5 4

3

S=1

6

Recall: u is k-hop away from s: length of shortest hop path from s to u is k

Shortest Path• BFS discovers shortest paths for all nodes that are

reachable from s! • pred[u] is a back-pointer storing previous hop

• To get shortest path to u: follows pred[u] to its predecessor v, and then use pred[v] to find its predecessor’s predecessor, and so on and on, until we get back to s

• u, pred[u], pred[pred[u]], … s

• What’s shortest path from s to 4 based upon BFS output?

34

1 2

5 4

3

S

d[2]=1 pred[2]=1

d[5]=1 pred[5]=1

d[3]=2 pred[3]=2

d[4]=2 pred[4]=2

BFS Tree• BFS tree G’=(V’,E’) is a subgraph of G=(V,E)

• V’ is a subset of V, including all nodes that are reachable from s

• E’ is a subset of E, contains by all edges from predecessor node to node

• e.g., (pred[2], 2), (pred[3], 3), (pred[4], 4), (pred[5],5), i.e., • (1,2), ( 1,5),(2,4), (2,3) colored in red below

35

1 2

5 4

3

S

d[2]=1 pred[2]=1

d[5]=1 pred[5]=1

d[3]=2 pred[3]=2

d[4]=2 pred[4]=2

BFS: Example• Suppose we perform BFS on following graph, with s=1 • What’s the output? Label each node with (d[v], pred[v])

– d[v]: distance (shortest hop) from s to v, for all v – pred[v]: predecessor node in shortest path from s to v,

36

Graph and Puzzle

• Many puzzles can be modeled as graph: • nodes: • edges: legal moves

• Such graph representation (state space of the puzzle) • allows one to use graph

algorithms (traversal, A* search) to solve puzzle

• Exercise: • how many nodes is “initial

State” node connected with? • Is the graph directed?

37

Exercise• First two glasses (one with a volume of 3 oz., one

with a volume of 5 oz.)are empty. The third glass (8 oz.) is full of water. How to get at least one glass to hold 4 oz. of water by pouring water from one glass to another (assuming no spillage).

• What’s best way (with minimal pouring)?

38

Water Pouring Puzzle

39

Summary• Graph Definition

• Graph Representation • Path, Cycle, Tree, Connectivity • Graph Traversal Algorithms

• Breath first search/traversal • Application of BFS

40