graph: representation and traversalbreadth-first search (bfs) • given a graph g = (v, e) , a...
Post on 01-Jul-2020
2 Views
Preview:
TRANSCRIPT
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
top related