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.
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.
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, v0, v1, … vm, such that each adjacent pair of vertices in the list are connected by an edge.
v1
v2
v3
v4
v0
Path
• A path in a graph is a sequence of vertices, v0, v1, … vm, such that each adjacent pair of vertices in the list are connected by an edge.
v1
v2
v3
v4
v0Example path:
v0, v3, v4
Path
• A path in a graph is a sequence of vertices, v0, v1, … vm, such that each adjacent pair of vertices in the list are connected by an edge.
v1
v2
v3
v4
v0Example path:
v0, v3, v4
v0, v3, v2, v1, v4
Path
• In a directed graph, the connection must go from source vi to target vi+1.
v1
v2
v3
v4
v0Is there a path from
v0 to v4?v3 to v1? v1 to v2? v2 to v1?
Example Task Network
Start
Find a realtor
Look at homes
Choose a home to buy
Apply for financing and
establish price limit
Investigateneighborhood
schools
Prepare offer
Investigatetermite and soil
reports
Presentoffer
0
20
5 9
2
15
10
3
2
How long will it take to buy a house? (The duration of each task isshown below each task).
Critical Path
Start
Find a realtor
Look at homes
Choose a home to buy
Apply for financing and
establish price limit
Investigateneighborhood
schools
Prepare offer
Investigatetermite and soil
reports
Presentoffer
0
20
5 9
2
15
10
3
2
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.
v1
v2
v3
v4
v0Example cycles:
v1, v2, v3, v2, v1
Cycles
• A cycle in a graph is a path that leads back to the first node in the path.
v1
v2
v3
v4
v0Example cycles:
v1, v2, v3, v2, v1
v0, v3, v4, v1, v0
DAG: Directed Acyclic GraphA 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.
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
C++ Adjacency Matrix
01
3
2 1 0 1 1
0 0 0 1
1 0 0 0
0 1 0 0
0 1 2 3 0123
bool graph_adjacency[4][4];
Adjacency Matrix: Weighted Edges
01
3
2 5.8 0 6.0 1.5
0 0 0 2.5
2.5 0 0 0
0 4.2 0 0
0 1 2 3
0123
double graph_adjacency[4][4];
6.0
2.5
4.2
2.5
5.8
1.5
Weighted Edges: An Example
$320$245
San FransiscoBoston
Chicago
$452
$60 $180Dallas
Flights. What’s the cheapest way to fly San Fransisco Boston?
Weighted Edges: An Example
18001200
San FransiscoBoston
Chicago
2800
2300 1600Dallas
Mileage for various hops from San Fransisco Boston*
*Mileage is not real, but for sake of example.
Weighted Edges: An Example
Fran Pat
ADSL provider100Kbs
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
Symmetry of Adjacency Matrix of Undirected Graph
01
3
2 0 1 1 1
1 0 0 1
1 0 0 0
1 1 0 0
0 1 2 3 0123
a[i][j]== a[j][i]
Non-symmetric Adjacency Matrix for Directed Graph
01
3
2 1 0 1 1
0 0 0 1
1 0 0 0
0 1 0 0
0 1 2 3 0123
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
01
3
2 1 0 1 1
0 0 0 1
1 0 0 0
0 1 0 0
0 1 2 3 0123
a[i][j] a[j][i]
Adjacency Matrix for Weighted Directed Graph
01
3
2 5 0 3 6
0 0 0 4
3 0 0 0
6 4 0 0
0 1 2 3 0123
a[i][j]=a[j][i]
3
32
6
6
4
45
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
01
3
2
2
3Null
Edge list for vertex 0
Null
Edge list for vertex 1
0
Edge list for vertex 2
1Null
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
01
3
2
Assume a Set template class is available:
Declare array of sets, one per node in graph:
Set<int> 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 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 AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4s
Q =
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4s
Q =
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4s
Q = 0
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 0
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 0 1
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 0 1 2
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 0 1 2 3
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 01 2 3
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 01 2 3
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 01 2 3 4
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 012 3 4
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4u
Q = 012 3 4
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4u
Q = 012 3 4
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4u
Q = 0123 4
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 0123 4
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 0123 4 5
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 01234 5
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 01234 5
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
u
Q = 012345
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
uQ = 012345
Breadth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a queue QFor each vertex u V – {s}
color[u] whitecolor[s] grayQ {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;
}
0
3
2
1
5
4
uQ =
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 AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4s
S =
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4s
S =
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4s
S = 0
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S =
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 1
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 32 1
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 3 2 1
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 3 2 1
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 32 1
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 32 15
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 32 15
3
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 52 1
3
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 52 14
3
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 52 14
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 4352 1
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 4352 1
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 43521
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S = 43521
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
u
S =
Depth First AlgorithmGiven graph G=(V,E) and source vertex s VCreate a stack SFor each vertex u V – {s}
color[u] whitecolor[s] grayS {s}While S {
u = Pop(S)for each v Adjacent[u]
if color[v] = white { color[v] gray Push(S,v)}
color[u] black;}
0
3
2
1
5
4
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.