Graphs I Kruse and Ryba Chapter 12

Undirected Graphs An undirected graph is a set of nodes and a set of edges between nodes; e.g.: The graph is undirected because its edges do not have a particular direction.

Edges We sometimes need to refer to the edges e i of a graph: e0e0 e1e1 e3e3 e4e4 e5e5 e2e2

Vertices We also need to refer to the vertices v j of a graph: v1v1 e0e0 e1e1 e3e3 e4e4 e5e5 e2e2 v2v2 v3v3 v4v4 v0v0

Undirected Graph Definition An undirected graph G = (V, E) is a finite set of vertices V, together with a finite set of edges E. Both sets might be empty (no vertices and no edges), which is called the empty graph. Each edge has associated with it two vertices. If two vertices are connected by an edge, they are said to be adjacent.

Undirected Graph Example: Subway Map

Another Undirected Graph: vBNS (fast internet backbone)

Directed Graphs In a directed graph each vertex has an associated direction; e.g.: Each edge is associated with two vertices: its source vertex and target vertex.

Directed Graph Examples Flow graph: vertices are pumping stations and edges are pipelines connecting them. Task network: each project has a number of component activities called tasks. Each task has a duration (amount of time needed to complete task).

Loops A loop is an edge that connects a vertex with itself; for example: Loops can occur in directed graphs or undirected graphs.

Multiple Edges In principle, a graph may have two or more edges connecting the same two vertices in the same direction: These are called multiple edges. In a graph diagram, each edge is drawn separately.

Simple Graphs A graph is said to be a simple graph, if: 1.the graph has no loops, and 2.no multiple edges

Path A path in a graph is a sequence of vertices, v 0, v 1, … v m, such that each adjacent pair of vertices in the list are connected by an edge. v1v1 v2v2 v3v3 v4v4 v0v0

Path A path in a graph is a sequence of vertices, v 0, v 1, … v m, such that each adjacent pair of vertices in the list are connected by an edge. v1v1 v2v2 v3v3 v4v4 v0v0 Example path: v 0, v 3, v 4

Path A path in a graph is a sequence of vertices, v 0, v 1, … v m, such that each adjacent pair of vertices in the list are connected by an edge. v1v1 v2v2 v3v3 v4v4 v0v0 Example path: v 0, v 3, v 4 v 0, v 3, v 2, v 1, v 4

Path In a directed graph, the connection must go from source v i to target v i+1. v1v1 v2v2 v3v3 v4v4 v0v0 Is there a path from v 0 to v 4 ? v 3 to v 1 ? v 1 to v 2 ? v 2 to v 1 ?

Example Task Network Start Find a realtor Look at homes Choose a home to buy Apply for financing and establish price limit Investigate neighborhood schools Prepare offer Investigate termite and soil reports Present offer How long will it take to buy a house? (The duration of each task is shown below each task).

Critical Path Start Find a realtor Look at homes Choose a home to buy Apply for financing and establish price limit Investigate neighborhood schools Prepare offer Investigate termite and soil reports Present offer The task will take as long as the maximum duration path from start to finish.

Cycles A cycle in a graph is a path that leads back to the first node in the path. v1v1 v2v2 v3v3 v4v4 v0v0 Example cycles: v 1, v 2, v 3, v 2, v 1

Cycles A cycle in a graph is a path that leads back to the first node in the path. v1v1 v2v2 v3v3 v4v4 v0v0 Example cycles: v 1, v 2, v 3, v 2, v 1 v 0, v 3, v 4, v 1, v 0

Does this graph have any cycles?

Cycles in Directed Graphs A cycle in a directed graph must follow edge directions; e.g.:

DAG: Directed Acyclic Graph A directed acyclic graph (DAG) must have no cycles; e.g.: In other words, there is no path that starts and ends at the same node.

Complete Graph An undirected graph which has an edge between every pair of vertices.

Connected Graph An undirected graph which has a path between every pair of vertices

Strongly Connected Graph A directed graph which has a path between every pair of vertices.

Weakly Connected Graph A directed graph which is connected, but not not strongly connected.

A DAG that is not Connected

Connected Components

Review of Terms Undirected vs. directed graphs Multiple edges, loops Simple graph Path Cycle Directed, acyclic graph (DAG) Connected, strongly connected, and weakly connected graphs Connected component

Graph Implementations

Adjacency Matrix

Adjacency Matrix

Adjacency Matrix

Adjacency Matrix

Adjacency Matrix

Adjacency Matrix

Adjacency Matrix

Adjacency Matrix

C++ Adjacency Matrix bool graph_adjacency[4][4];

Adjacency Matrix: Weighted Edges double graph_adjacency[4][4];

Weighted Edges: An Example $320 $245 San Fransisco Boston Chicago $452 $60 $180 Dallas Flights. What’s the cheapest way to fly San Fransisco  Boston?

Weighted Edges: An Example San Fransisco Boston Chicago Dallas Mileage for various hops from San Fransisco  Boston* *Mileage is not real, but for sake of example.

Weighted Edges: An Example Fran Pat ADSL provider 100Kbs Available internet bandwidth on various paths between an ADSL provider and customers*. *This is a simplication for sake of example, and bit rates are fictional. 1Gbs 100Kbs 500Kbs

Adjacency Matrix: Undirected Graph bool graph_adjacency[4][4];

Adjacency Matrix: Undirected Graph No loops  zero diagonal.

Adjacency Matrix: Undirected Graph

Adjacency Matrix: Undirected Graph

Adjacency Matrix: Undirected Graph

Adjacency Matrix: Undirected Graph

Symmetry of Adjacency Matrix of Undirected Graph a[i][j]== a[j][i]

Non-symmetric Adjacency Matrix for Directed Graph a[i][j]  a[j][i]

Symmetric Adjacency Matrix An undirected graph will always have a symmetric adjacency matrix. A directed graph may not have a symmetric adjacency matrix. If a directed graph has a symmetric matrix, what does that mean?

Non-symmetric Adjacency Matrix Unweighted Directed Graph a[i][j]  a[j][i]

Add an Edge a[i][j]=a[j][i]

Adjacency Matrix for Weighted Directed Graph a[i][j]=a[j][i]

Time Complexity Analysis Given N we have vertices in a graph, and we use the adjacency matrix representation. 1.What is the worst case and average complexity of inserting an edge in the graph? 2.What is the worst case and average complexity of removing an edge in the graph? 3.What is the complexity of retrieving a list of all nodes that share and edge with a particular vertex?

Representing Graphs with Edge Lists Null Edge list for vertex 0 Null Edge list for vertex 1 0 Edge list for vertex 2 1 Null Edge list for vertex 3 Null

Time Complexity Analysis Given N we have vertices in a graph, and we use the edge list representation. 1.What is the worst case and average complexity of inserting an edge in the graph? 2.What is the worst case and average complexity of removing an edge in the graph? 3.What is the complexity of retrieving a list of all nodes that share and edge with a particular vertex?

Representing Graphs with Edge Sets Assume a Set template class is available: Declare array of sets, one per node in graph: Set connections[N]; Each node’s set contains the indices of all vertices that it is connected to.

Time Complexity Analysis Given N we have vertices in a graph, and we use the edge set representation. 1.What is the worst case and average complexity of inserting an edge in the graph? 2.What is the worst case and average complexity of removing an edge in the graph? 3.What is the complexity of retrieving a list of all nodes that share and edge with a particular vertex?

Graph Implementations Summary Adjacency matrix Edge lists Edge sets

Graph Searching

Graph Search Choice of container –If a stack is used as the container for adjacent vertices, we get depth first search. –If a list is used as the container adjacent vertices, we get breadth first search.

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; }

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } s Q = 

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } s Q = 

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } s Q = 0

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 0

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 01

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 012

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 0123

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 0123

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 0123

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 01234

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 01234

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 01234

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 01234

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 01234

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 01234

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q =

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q =

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q =

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q =

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q =

Breadth First Algorithm Given graph G=(V,E) and source vertex s  V Create a queue Q For each vertex u  V – {s} color[u]  white color[s]  gray Q  {s} While Q   { u  head[Q]; for each v  Adjacent[u] if color[v] = white { color[v]  gray Enqueue(Q,v) } Dequeue(Q) color[u]  black; } u Q = 

Graph Search Choice of container –If a stack is used as the container for adjacent vertices, we get depth first search. –If a list is used as the container adjacent vertices, we get breadth first search.

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } s S = 

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } s S = 

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } s S =  0

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S = 

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  1

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  321

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  321

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  321

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  321

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  3215

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  3215

3 Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  521

3 Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  5214

3 Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  5214

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  43521

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  43521

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  43521

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S =  43521

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S = 

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S = 

Graph Search Choice of container –If a stack is used as the container for adjacent vertices, we get depth first search. –If a list is used as the container adjacent vertices, we get breadth first search.

Depth First Algorithm Given graph G=(V,E) and source vertex s  V Create a stack S For each vertex u  V – {s} color[u]  white color[s]  gray S  {s} While S   { u = Pop(S) for each v  Adjacent[u] if color[v] = white { color[v]  gray Push(S,v) } color[u]  black; } u S = 