GRAPH THEORY

By: Puneet Patil

A model
Many structures in real world can be represented on
paper by means of a diagram consisting of a set of points
together with lines joining some or all pairs of these points.
For example,




A vertex : an object
An edge : a relation between two objects

What is a graph?




A graph G consists of a set of vertices and a set of edges.
G = {V,E}
In this example, V = {A,B,C,D,E,F}, E = {AB, BC, BD, CD,
DF, DE,EF}.
Any graph can be drawn on paper in many ways the
important thing is which vertices are connected (adjacent)
to each other.
Why study graph theory?
I Useful set of techniques for solving real-world problems
particularly for different kinds of optimization.
I Graph theory is useful for analyzing things that are
connected to other things, which applies almost
everywhere.
I Some difficult problems become easy when represented
using a graph.
I There are lots of unsolved questions in graph theory:
solve one and become rich and famous1.
Graphs Networks
Graph
(Network)
Vertexes
(Nodes)
Edges
(Arcs)
Flow
Communications
Telephones
exchanges,
computers, satellites
Cables, fiber optics,
microwave relays Voice, video, packets
Circuits
Gates, registers,
processors
Wires Current
Mechanical
Joints
Rods, beams,
springs
Heat, energy
Hydraulic
Reservoirs, pumping
stations, lakes
Pipelines Fluid, oil
Financial
Stocks, currency Transactions Money
Transportation
Airports, rail yards,
street intersections
Highways, rail beds,
airway routes
Freight, vehicles,
passengers
Adjacent, Loop, Multiple edges
Two vertices are adjacent and are neighbors if they are
the endpoints of an edge
Example:
A and B are adjacent
A and D are not adjacent
Loop : An edge whose endpoints are equal.
Multiple edges : Edges have the same pair of endpoints.
Simple graph : A graph has no loops
or multiple edges.


Directed Graph
An edge e e E of a directed graph is
represented as an ordered pair (u,v), where u,
v e V. Here u is the initial vertex and v is the
terminal vertex. Also assume here that u v
2
4
3
1
V = { 1, 2, 3, 4}, | V | = 4
E = {(1,2), (2,3), (2,4), (4,1), (4,2)}, | E |=5
Undirected Graph
2
4
3
1
V = { 1, 2, 3, 4}, | V | = 4
E = {(1,2), (2,3), (2,4), (4,1)}, | E |=4
An edge e e E of an undirected graph is
represented as an unordered pair
(u,v)=(v,u), where u, v e V. Also assume
that u v
Degree of a Vertex
Degree of a vertex in an undirected graph is the number
of edges incident on it. In a directed graph, the out
degree of a vertex is the number of edges leaving it and
the in degree is the number of edges entering it
2
4
3
1
2
4
3
1
The degree of vertex 2
is 3
The in degree of vertex 2
is 2 and the in degree of
vertex 4 is 1
Weighted Graph
A weighted graph is a graph for which each edge has an
associated weight, usually given by a weight function w: E
R
2
4
3
1
2
4
3
1
1.2
2.1
0.2
0.5 4
8
6
2
9
Walks and Paths
3
2
3
4
1
1
V
5
V
4

V
3

V
2

V
1

V
6

4
1
_
A walk is an sequence of nodes (v
1
, v
2
,..., v
L
) such that
{(v
1
, v
2
), (v
1
, v
2
),..., (v
1
, v
2
)} E, e.g. (V
2
, V
3
,V
6
, V
5
,V
3
)
A simple path is a walk with no repeated nodes, e.g. (V
1
,
V
4
,V
5
, V
2
,V
3
)
A cycle is an walk (v
1
, v
2
,..., v
L
) where v
1
=v
L
with no other
nodes repeated and L>3, e.g. (V
1
, V
2
,V
5
, V
4
,V
1
)
A graph is called cyclic if it contains a cycle; otherwise it is
called acyclic

Complete Graphs
A
D
C
B
4 nodes and (4*3)/2 edges
V nodes and V*(V-1)/2
edges
C
A
B
3 nodes and 3*2 edges
V nodes and V*(V-1)
edges

A complete graph is an undirected/directed graph in which
every pair of vertices is adjacent. If (u, v ) is an edge in a
graph G, we say that vertex v is adjacent to vertex u.
Connected Graphs
A
D
E
F
B C
A B
C D
An undirected graph is connected if
you can get from any node to any
other by following a sequence of
edges OR any two nodes are
connected by a path

Bipartite Graph
A bipartite graph
is an undirected graph
G = (V,E) in which V can be
partitioned into 2 sets V1 and V2
such that ( u,v) e E implies
either
u e V1 and v e V2
OR
v e V1 and u e V2.
u
1
u
2
u
3
u
4
v
1
v
2
v
3
V1
V2
Trees
A
B
D
F
C
E
Let G = (V, E ) be an undirected graph.
The following statements are equivalent,

1. G is a tree
2. Any two vertices in G are connected
by unique simple path
3. G is connected, but if any edge is
removed from E, the resulting graph is
disconnected
4. G is connected, and | E | = | V | -1
5. G is acyclic, and | E | = | V | -1
6. G is acyclic, but if any edge is added
to E, the resulting graph contains a
cycle
Planar graph
If graph can be drawn in the plane without any of its
edges crossing each other, then it is called Planar graph.
Otherwise its called as Non planar graph.







Non planar Planar
Adjacency matrix
Let G = (V, E), |V| = n and |E|=m
The adjacency matrix of G written A(G), is the n-by-n
matrix in which entry a
i,j
is the number of edges in G
with endpoints {v
i
, v
j
}.
a
b
c
d
e
w
x
y
z
w x y z
0 1 1 0
1 0 2 0
1 2 0 1
0 0 1 0
w
x
y
z
Incidence Matrix
Let G = (V, E), |V| = n and |E|=m
The incidence matrix M(G) is the n-by-m matrix in
which entry m
i,j
is 1 if v
i
is an endpoint of e
i
and
otherwise is 0.
a
b
c
d
e
w
x
y
z
a b c d e
1 1 0 0 0
1 0 1 1 0
0 1 1 1 1
0 0 0 0 1
w
x
y
z
Isomorphism
An isomorphism from a simple graph G to a simple
graph H is a bijection f:V(G)V(H) such that uv eE(G) if
and only if f(u)f(v) e E(H)
We say G is isomorphic to H, written G ~ H
H
G
w
x
z
y
c
d
b
a
f
1
: w x y z
c b d a
f
2
: w x y z
a d b c
20
Example: H
1
, H
2
, and H
3
are subgraphs of G
c
d
a
b
d
e
a
b
c
d
e
H
1
G

H
3
H
2
a
b
c
d
e
Subgraph
Clique- is a complete sub graph.
Clique number (G) - is cardinality of its largest clique.
Clique cover number (G) - is the minimum number
of cliques in G needed to cover the vertex set of G.
Stable set (G) - is a subset of vertices with the property
that no two vertices in the stable set are adjacent.
Chromatic number (G) - is the smallest number of
colors needed to color the vertices of so that no two
adjacent vertices share the same color.
(G) (G)
(G) (G)
Branch & Bound algorithm
To apply BnB, one must be able to partition the solution
space into subsets. Often the subsets are arranged in a
tree structure. Leaves in the tree are solutions. Internal
nodes represent the set of solutions below them in the
tree (the subtree).
How Branch-and-Bound Works
Some nodes in the tree are active.These are the nodes
waiting to be explored.
Branching refers to exploring the sub tree of an active
node.
Bounding refers to estimating a bound on the solutions in
the sub tree rooted at the active node.
The Branch-and-Bound Algorithm
begin
activeset :=f0g;
bestval:=NULL;
currentbest:=NULL;
while activeset is not empty do
choose a branching node, node k 2 activeset;
remove node k from activeset;
generate the children of node k, child i, i=1,. . . ,nk,
and corresponding optimistic bounds obi;
for i=1 to nk do
if obi worse than bestval then kill child i;
else if child is a complete solution then
bestval:=obi, currentbest:=child i;
else add child i to activeset
end for
end while
end
Example
Dynamic Programming
Dynamic Programming is a general algorithm design
technique for solving problems defined by or formulated as
recurrences with overlapping sub instances
Programming here means planning

Main idea:
- set up a recurrence relating a solution to a larger instance
to solutions of some smaller instances
- solve smaller instances once
- record solutions in a table
- extract solution to the initial instance from that table

Example
Ingredients:
Instances: The possible inputs to the problem.
Solutions for Instance: Each instance has an exponentially large
set of valid solutions.
Cost of Solution: Each solution has an easy-to-compute cost or
value.
Specification
Preconditions: The input is one instance.
Postconditions: A valid solution with optimal cost. (minimum
or maximum)
Optimization Problems
Greedy Solutions to Optimization
Problems
Surprisingly, many important and practical
optimization problems can be solved this way.
Every two-year-old knows the greedy algorithm.
In order to get what you want,
just start grabbing what looks best.
Example 1: Making Change
Problem: Find the minimum # of quarters, dimes,
nickels, and pennies that total to a given amount.
The Greedy Choice
Commit to the object that looks the ``best''
Must prove that this locally greedy choice
does not have negative global consequences.
Instance: A drawer full of coins and an amount of change to return
25

25

25

25

25

25

25

25

25

25

10

10

10

10

10

10

10

10

10

10

5

5

5

5

5

5

5

5

5

5

1

1

1

1

1

1

1

1

1

1

Amount = 92

Solutions for Instance:
A subset of the coins in the drawer that total the amount
Making Change Example
Instance: A drawer full of coins and an amount of change to return
Solutions for Instance: A subset of the coins that total the amount.
25

25

25

25

25

25

25

25

25

25

10

10

10

10

10

10

10

10

10

10

5

5

5

5

5

5

5

5

5

5

1

1

1

1

1

1

1

1

1

1

Amount = 92

Cost of Solution: The number of coins in the solution = 14
Making Change Example
Goal: Find an optimal valid solution.
25

25

25

25

25

25

25

25

25

25

10

10

10

10

10

10

10

10

10

10

5

5

5

5

5

5

5

5

5

5

1

1

1

1

1

1

1

1

1

1

Amount = 92

Making Change Example
Greedy Choice:
Does this lead to an optimal # of coins?
Start by grabbing quarters until exceeds amount,
then dimes, then nickels, then pennies.
Cost of Solution: 7
Instance: A drawer full of coins and an amount of change to return
Hard Making Change Example
Greedy Choice: Start by grabbing a 4-cent coin.
Problem: Find the minimum # of
4, 3, and 1 cent coins to make up 6 cents.
Consequences:
4+1+1 = 6 mistake
3+3=6 better
Greedy Algorithm does not work!
Shortest Path
Generalize distance to weighted setting
Digraph G = (V,E) with weight function W: E R
(assigning real values to edges)
Weight of path p = v
1
v
2
v
k
is


Shortest path = a path of the minimum weight
Applications
static/dynamic network routing
robot motion planning
map/route generation in traffic
1
1
1
( ) ( , )
k
i i
i
w p w v v

+
=
=

Shortest-Path Problems
Shortest-Path problems
Single-source (single-destination). Find a shortest path from a
given source (vertex s) to each of the vertices.
Single-pair. Given two vertices, find a shortest path between them.
Solution to single-source problem solves this problem efficiently,
too.
All-pairs. Find shortest-paths for every pair of vertices. Dynamic
programming algorithm.
Negative Weights and Cycles?
Negative edges are OK, as long as there are no negative
weight cycles (otherwise paths with arbitrary small
lengths would be possible)
Shortest-paths can have no cycles (otherwise we could
improve them by removing cycles)
Any shortest-path in graph G can be no longer than n 1 edges,
where n is the number of vertices
Relaxation
For each vertex v in the graph, we maintain v.d(), the
estimate of the shortest path from s, initialized to at the
start
Relaxing an edge (u,v) means testing whether we can
improve the shortest path to v found so far by going
through u
5
u v
v u
2
2
9
5 7
Relax(u,v)
5
u v
v u
2
2
6
5 6
Relax(u,v)
Relax (u,v,G)
if v.d() > u.d()+G.w(u,v) then
v.setd(u.d()+G.w(u,v))
v.setparent(u)
Dijkstra's Algorithm
Non-negative edge weights
Greedy, similar to Prim's algorithm for MST
Like breadth-first search (if all weights = 1, one can simply
use BFS)
Use Q, a priority queue ADT keyed by v.d() (BFS used
FIFO queue, here we use a PQ, which is re-organized
whenever some d decreases)
Basic idea
maintain a set S of solved vertices
at each step select "closest" vertex u, add it to S, and relax all
edges from u
Dijkstras Pseudo Code
Input: Graph G, start vertex s
relaxing
edges
Dijkstra(G,s)
01 for each vertex u e G.V()
02 u.setd()
03 u.setparent(NIL)
04 s.setd(0)
05 S C // Set S is used to explain the algorithm
06 Q.init(G.V()) // Q is a priority queue ADT
07 while not Q.isEmpty()
08 u Q.extractMin()
09 S S {u}
10 for each v e u.adjacent() do
11 Relax(u, v, G)
12 Q.modifyKey(v)
Dijkstras Example


0
s
u v
y x
10
5
1
2 3
9
4 6
7
2
10
5
0
s
u v
y x
10
5
1
2 3
9
4 6
7
2
Dijkstra(G,s)
01 for each vertex u e G.V()
02 u.setd()
03 u.setparent(NIL)
04 s.setd(0)
05 S C
06 Q.init(G.V())
07 while not Q.isEmpty()
08 u Q.extractMin()
09 S S {u}
10 for each v e u.adjacent() do
11 Relax(u, v, G)
12 Q.modifyKey(v)
Dijkstras Example (2)
u v
8 14
5 7
0
s
y x
10
5
1
2 3
9
4 6
7
2
8 13
5 7
0
s
u v
y x
10
5
1
2 3
9
4 6
7
2
Dijkstra(G,s)
01 for each vertex u e G.V()
02 u.setd()
03 u.setparent(NIL)
04 s.setd(0)
05 S C
06 Q.init(G.V())
07 while not Q.isEmpty()
08 u Q.extractMin()
09 S S {u}
10 for each v e u.adjacent() do
11 Relax(u, v, G)
12 Q.modifyKey(v)
Dijkstras Example (3)
8 9
5 7
0
u v
y x
10
5
1
2 3
9
4 6
7
2
8 9
5 7
0
u v
y x
10
5
1
2 3
9
4 6
7
2
Dijkstra(G,s)
01 for each vertex u e G.V()
02 u.setd()
03 u.setparent(NIL)
04 s.setd(0)
05 S C
06 Q.init(G.V())
07 while not Q.isEmpty()
08 u Q.extractMin()
09 S S {u}
10 for each v e u.adjacent() do
11 Relax(u, v, G)
12 Q.modifyKey(v)
Dijkstras Running Time
Extract-Min executed |V| time
Decrease-Key executed |E| time
Time = |V| T
Extract-Min
+ |E| T
Decrease-Key
T depends on different Q implementations
Q T(Extract-
Min)
T(Decrease-Key) Total
array O(V) O(1) O(V
2
)
binary heap O(lg V) O(lg V) O(E lg V)
Fibonacci heap O(lg V) O(1) (amort.) O(V lgV + E)
46
Bellman-Ford Algorithm
Dijkstras doesnt work when there are negative edges:
Intuition we can not be greedy any more on the assumption that
the lengths of paths will only increase in the future
Bellman-Ford algorithm detects negative cycles (returns
false) or returns the shortest path-tree

Bellman-Ford Algorithm
Bellman-Ford(G,s)
01 for each vertex u e G.V()
02 u.setd()
03 u.setparent(NIL)
04 s.setd(0)
05 for i 1 to |G.V()|-1 do
06 for each edge (u,v) e G.E() do
07 Relax (u,v,G)
08 for each edge (u,v) e G.E() do
09 if v.d() > u.d() + G.w(u,v) then
10 return false
11 return true

Bellman-Ford Example
5


0
s
z y
6
7
8
-3
7
2
9
-2
x t
-4
6
7
0
s
z y
6
7
8
-3
7
2
9
-2
x t
-4
5
6 4
7 2
0
s
z y
6
7
8
-3
7
2
9
-2
x t
-4
5
2 4
7 2
0
s
z y
6
7
8
-3
7
2
9
-2
x t
-4
5
Bellman-Ford Example
2 4
7 2
0
s
z y
6
7
8
-3
7
2
9
-2
x t
-4
Bellman-Ford running time:
(|V|-1)|E| + |E| = O(VE)
5
Thank you !