1 / 19

# Week -7-8 Topic - Graph Algorithms CSE 5311 - PowerPoint PPT Presentation

Week -7-8 Topic - Graph Algorithms CSE – 5311. Prepared by:- Sushruth Puttaswamy Lekhendro Lisham . Contents. Different Parts of Vertices used in Graph Algorithms Analysis of DFS Analysis of BFS Minimum Spanning Tree Kruskal’s Algorithm Shortest Path’s Dijkshitra’s Algorithm.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'Week -7-8 Topic - Graph Algorithms CSE 5311' - hien

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Week -7-8Topic - Graph AlgorithmsCSE – 5311

Prepared by:-

Sushruth Puttaswamy

Lekhendro Lisham

• Different Parts of Vertices used in Graph Algorithms

• Analysis of DFS

• Analysis of BFS

• Minimum Spanning Tree

• Kruskal’s Algorithm

• Shortest Path’s

• Dijkshitra’s Algorithm

Different Parts of Vertices (used in Graph Algorithms)

Vertices of the Graph are kept in 3 parts as below:

• Visited: Vertices already selected.

• Fringe : Vertices to be considered for

next selection.

• Unvisited: Vertices yet to consider as a possible candidate.

Visited

Fringe

Unvisited

• For DFS, the FringePart is kept in a STACK while for BFS

QUEUE is used.

• Explores a graph using greedy method.

• Vertices are divided into 3 parts as it proceeds i.e. into Visited, Fringe & Unvisited

• Fringe part is maintained in a Stack.

• The path is traced from last visited node.

• Element pointed by TOS is the next vertex to be considered by DFS algorithm to select for Visited Part.

a b e

d c

Graph with 5 Vertices

b

V

F

U

F

U

a

b

c

d

e

d

a

c

e

d

b

e

a

e

c

TOS

b

b

d

c

d

(U/V/F) 1-D Array

Fringe (Stack)

Analysis of DFS

For a Graph G=(V, E) and n = |V| & m=|E|

• When Adjacency List is used

• Complexity is O(m+n)

• When Adjacency Matrix is used

• This again requires a stack to maintain the fringe & an array for maintaining the state of a node.

• Scanning each row for checking the connectivity of a Vertex is in order O(n).

• So, Complexity is O(n2).

2

• To check if a graph is connected.The algorithm ends when the Stack becomes empty.

• Graph is CONNECTED if all the vertices are visited.

• Graph is DISCONNECTED if one or more vertices

remained unvisited.

• Finding the connected components of a disconnected graph.Repeat 1 until all the vertices become visited. Next vertex can also be taken randomly.

• Check if a graph is bi-connected(i.e. if 2 distinct paths exist between any 2 nodes.).

• Detecting if a given directed graph is strongly connected( path exists between a-b & b-a).

Hence DFS is the champion algorithm for all connectivity problems

• Fringe part is maintained in a Queue.

• The trees developed are more branched & wider.

• When Adjacency List is used

• Complexity is O(m+n)

• When Adjacency Matrix is used

• This requires a Queue to maintain the fringe & an array for maintaining the state of a node.

• Scanning each row for checking the connectivity of a Vertex is in order O(n).

• So, Complexity is O(n2).

• A spanning tree of a connected Graph G is a sub-graph of G which covers all the vertices of G.

• A minimum-cost spanning tree is one whose edge weights add up to the least among all the spanning trees.

• A given graph may have more than one spanning tree.

• DFS & BFS give rise to spanning trees, but they don’t consider weights.

• The least weight edge of the graph is always present in the MST.

w3

w2

c

d

h

Let this be a MST. Also let us assume that the shortest edge is not part of this tree. Consider node g & h.

All edges on the path between these nodes are longer.(w1,w2,w3)

Let us take any edge (ex-w1) & delete it. We will then connect g & h directly.

But this edge has a lighter weight then already existing edges which is a contradiction.

w1

g

• For any pair of vertices a & b, the edges along the path from a to b have to be greater than the weight of (a,b).

• An algorithm to find the minimum spanning tree of connected graph.

• It makes use of the previously mentioned properties.

Step 1: Initially all the edges of the graph are sorted based on their weights.

Step2: Select the edge with minimum weight from the sorted list in step 1.Selected edge shouldn’t form a cycle. Selected edge is added into the tree or forest.

Step 3: Repeat step 2 till the tree contains all nodes of the graph.

• This algorithm works because when any edge is rejected it will be longer than the already existing edge(s).

• The Union-Find data structure is tailor made to implement this algorithm.

• Cycle formation between any 2 vertices a & b is checked if Find(a)=Find(b).

• Applet Demo Link.

• If an adjacency list is used.

We have n vertices & m edges the following steps are followed.

• Sort the edges – mlogm

• Find operation – 2m= O(m)

• Union - n-1= O(n)

O(mlogm)= O(mlogn )= O(mlog n).

If we use path compression then find & union become m times inverse Ackerman’s function.

But sorting always takes mlogm time.

2

• The problem is to find shortest paths among nodes.

• There are 3 different versions of this problem as shown below:

• Single source single destination shortest path (SSSP)

• Single source all destinations shortest path (SSAP).

• All pairs shortest path.

• For un-weighted graphs:

• BFS can be used for 1.

• BFS can used to for 2.

• Running BFS from all nodes is presently the best algorithm for 3.

• This is an algorithm for finding the shortest path in a weighted graph.

• It finds the shortest path from a single source node to all other nodes.

• The shortest path from a single node to all destinations is a tree.

• The following applet gives a very good demonstration of the Dijkshitra’s Algorithm. It finds the shortest distances from 1 city to all the remaining cities to which it has a path.

Applet

DIJKSTRA (G, w, s)

• INITIALIZE-SINGLE-SOURCE(G, s)

• S ← ø

• Q ← V[G]

• while Q ≠ ø

• do u ← EXTRACT-MIN(Q)

• S ← S U {u}

• for each vertex vЄAdj[u] do

• if d[v] > d[u] + w (u, v)

• then d[v] ← d[u] + w (u, v)

• π[v] ← u

The algorithm repeatedly selects the vertex u with the minimum shortest-path estimate, adds u to S, and relaxes all edges leaving u.

• For a Graph G=(V, E) and n = |V| & m=|E|

• When Binary Heap is used

• Complexity is O((m+n) log n)

• When Fibonacci Heap is used

• Complexity is O( m + n log n)