lOMoARcPSD|45122995

UNIT - 2
DIVIDE & CONQUER AND GREEDY
1.1 Divide and Conquer

1.2 General Method

1.3 Binary Search

1.4 Merge Sort

1.5 Quick Sort and its performance

1.1 Divide and Conquer

Definition:
Divide & conquer is a general algorithm design strategy with a general plan as follows:
1. DIVIDE:
A problem‘s instance is divided into several smaller instances of the same
problem, ideally of about the same size.
2. RECUR:
Solve the sub-problem recursively.
3. CONQUER:
If necessary, the solutions obtained for the smaller instances are combined to get a
solution to the original instance.

Diagram 1 shows the general divide & conquer plan

Problem
of size n

Problem Problem
of size n of size n

Solution to sub Solution to sub

problem 1 problem 1

Solution to
original
problem

NOTE:

19
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

The base case for the recursion is sub-problem of constant size.

Advantages of Divide & Conquer technique:

• For solving conceptually difficult problems like Tower Of Hanoi, divide &
conquer is a powerful tool
• Results in efficient algorithms
• Divide & Conquer algorithms are adapted foe execution in multi-processor
machines
• Results in algorithms that use memory cache efficiently.

Limitations of divide & conquer technique:

• Recursion is slow
• Very simple problem may be more complicated than an iterative approach.
Example: adding n numbers etc

1.2 General Method

General divide & conquer recurrence:
An instance of size n can be divided into b instances of size n/b, with ―
a‖ of them needing
to be solved. [ a ≥ 1, b > 1].
Assume size n is a power of b. The recurrence for the running time T(n) is as follows:

T(n) = aT(n/b) + f(n)

where:
f(n) – a function that accounts for the time spent on dividing the problem into
smaller ones and on combining their solutions

Therefore, the order of growth of T(n) depends on the values of the constants a & b and
the order of growth of the function f(n).

Master theorem
Theorem: If f(n) Є Θ (nd) with d ≥ 0 in recurrence equation
T(n) = aT(n/b) + f(n),
then

Θ (nd) if a < bd
T(n) = Θ (ndlog n) if a = bd
Θ (nlogba ) if a > bd

Example:

Let T(n) = 2T(n/2) + 1, solve using master theorem.

Solution:
Here: a = 2
b=2
f(n) = Θ(1)

20
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

d=0
Therefore:
a > bd i.e., 2 > 20
Case 3 of master theorem holds good. Therefore:
T(n) Є Θ (nlogba )
Є Θ (nlog22 )
Є Θ (n)

1.3Binary Search
Description:
Binary tree is a dichotomic divide and conquer search algorithm. Ti inspects the middle
element of the sorted list. If equal to the sought value, then the position has been found.
Otherwise, if the key is less than the middle element, do a binary search on the first half,
else on the second half.
Algorithm:
Algorithm can be implemented as recursive or non-recursive algorithm.

ALGORITHM BinSrch ( A[0 … n-1], key)

//implements non-recursive binary search
//i/p: Array A in ascending order, key k
//o/p: Returns position of the key matched else -1

l 0
r n-1

while l ≤ r do
m ( l + r) / 2
if key = = A[m]
return m
else
if key < A[m]
r m-1
else
l m+1
return -1
Analysis:
• Input size: Array size, n
• Basic operation: key comparison
• Depend on
Best – key matched with mid element
Worst – key not found or key sometimes in the list
• Let C(n) denotes the number of times basic operation is executed. Then
Cworst(n) = Worst case efficiency. Since after each comparison the algorithm
divides the problem into half the size, we have
Cworst(n) = Cworst(n/2) + 1 for n > 1

21
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

C(1) = 1
• Solving the recurrence equation using master theorem, to give the number of
times the search key is compared with an element in the array, we have:
C(n) = C(n/2) + 1
a=1

b=2

f(n) = n0 ; d = 0

case 2 holds:
C(n) = Θ (ndlog n)
= Θ (n0log n)
= Θ ( log n)
Applications of binary search:
• Number guessing game
• Word lists/search dictionary etc
Advantages:
• Efficient on very big list
• Can be implemented iteratively/recursively
Limitations:
• Interacts poorly with the memory hierarchy
• Requires given list to be sorted
• Due to random access of list element, needs arrays instead of linked list.
1.4Merge Sort
Definition:
Merge sort is a sort algorithm that splits the items to be sorted into two groups,
recursively sorts each group, and merges them into a final sorted sequence.
Features:
• Is a comparison based algorithm
• Is a stable algorithm
• Is a perfect example of divide & conquer algorithm design strategy
• It was invented by John Von Neumann
Algorithm:

ALGORITHM Mergesort ( A[0… n-1] )

//sorts array A by recursive mergesort
//i/p: array A
//o/p: sorted array A in ascending order

if n > 1
copy A[0… (n/2 -1)] to B[0… (n/2 -1)]
copy A[n/2… n -1)] to C[0… (n/2 -1)]
Mergesort ( B[0… (n/2 -1)] )
Mergesort ( C[0… (n/2 -1)] )
Merge ( B, C, A )

22
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

ALGORITHM Merge ( B[0… p-1], C[0… q-1], A[0… p+q-1] )

//merges two sorted arrays into one sorted array
//i/p: arrays B, C, both sorted
//o/p: Sorted array A of elements from B & C

I →0
j→0
k→0
while i < p and j < q do
if B[i] ≤ C[j]
A[k] →B[i]
i→i + 1
else
A[k] →C[j]
j→j + 1
k→k + 1
if i == p
copy C [ j… q-1 ] to A [ k… (p+q-1) ]
else
copy B [ i… p-1 ] to A [ k… (p+q-1) ]
Example:
Apply merge sort for the following list of elements: 6, 3, 7, 8, 2, 4, 5, 1

6 3 7 8 2 4 5 1

6 3 7 8 2 4 5 1

6 3 7 8 2 4 5 1

6 3 7 8 2 4 5 1

3 6 7 8 2 4 1 5

3 6 7 8 1 2 4 5

1 2 3 4 5 6 7 8

23
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

Analysis:
• Input size: Array size, n
• Basic operation: key comparison
• Best, worst, average case exists:
Worst case: During key comparison, neither of the two arrays becomes empty
before the other one contains just one element.
• Let C(n) denotes the number of times basic operation is executed. Then
C(n) = 2C(n/2) + Cmerge(n) for n > 1
C(1) = 0
where, Cmerge(n) is the number of key comparison made during the merging stage.
In the worst case:
Cmerge(n) = 2 Cmerge(n/2) + n-1 for n > 1
Cmerge(1) = 0
• Solving the recurrence equation using master theorem:
C(n) = 2C(n/2) + n-1 for n > 1
C(1) = 0
Here a=2
b=2
f(n) = n; d = 1
Therefore 2 = 21, case 2 holds
C(n) = Θ (ndlog n)
= Θ (n1log n)
= Θ (n log n)
Advantages:
• Number of comparisons performed is nearly optimal.
• Mergesort will never degrade to O(n2)
• It can be applied to files of any size
Limitations:
• Uses O(n) additional memory.
1.6 Quick Sort and its performance
Definition:
Quick sort is a well –known sorting algorithm, based on divide & conquer approach. The
steps are:
1. Pick an element called pivot from the list
2. Reorder the list so that all elements which are less than the pivot come before the
pivot and all elements greater than pivot come after it. After this partitioning, the
pivot is in its final position. This is called the partition operation
3. Recursively sort the sub-list of lesser elements and sub-list of greater elements.
Features:
• Developed by C.A.R. Hoare
• Efficient algorithm
• NOT stable sort
• Significantly faster in practice, than other algorithms

24
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

ALGORITHM Quicksort (A[ l …r ])

//sorts by quick sort
//i/p: A sub-array A[l..r] of A[0..n-1],defined by its left and right indices l and r
//o/p: The sub-array A[l..r], sorted in ascending order
if l < r
Partition (A[l..r]) // s is a split position
Quicksort(A[l..s-1])
Quicksort(A[s+1..r]
ALGORITHM Partition (A[l ..r])
//Partitions a sub-array by using its first element as a pivot
//i/p: A sub-array A[l..r] of A[0..n-1], defined by its left and right indices l and r (l < r)
//o/p: A partition of A[l..r], with the split position returned as this function‘s value
p→A[l]
i→l
j→r + 1;
Repeat
repeat i→i + 1 until A[i] >=p //left-right scan
repeat j→j – 1 until A[j] < p //right-left scan
if (i < j) //need to continue with the scan
swap(A[i], a[j])
until i >= j //no need to scan
swap(A[l], A[j])
return j
Example: Sort by quick sort the following list: 5, 3, 1, 9, 8, 2, 4, 7, show recursion tree.

25
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

Analysis:
• Input size: Array size, n
• Basic operation: key comparison
• Best, worst, average case exists:
Best case: when partition happens in the middle of the array each time.
Worst case: When input is already sorted. During key comparison, one half is
empty, while remaining n-1 elements are on the other partition.
• Let C(n) denotes the number of times basic operation is executed in worst case:
Then
C(n) = C(n-1) + (n+1) for n > 1 (2 sub-problems of size 0 and n-1 respectively)
C(1) = 1

Best case:
C(n) = 2C(n/2) + Θ(n) (2 sub-problems of size n/2 each)

• Solving the recurrence equation using backward substitution/ master theorem,

we have:
C(n) = C(n-1) + (n+1) for n > 1; C(1) = 1
C(n) = Θ (n2)

C(n) = 2C(n/2) + Θ(n).

= Θ (n1log n)
= Θ (n log n)

NOTE:
The quick sort efficiency in average case is Θ( n log n) on random input.

26
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

UNIT - 3
THE GREEDY METHOD
3.1 The General Method
3.2 Knapsack Problem
3.3 Job Sequencing with Deadlines
3.4 Minimum-Cost Spanning Trees
3.5 Prim’sAlgorithm
3.6 Kruskal’s Algorithm
3.7 Single Source Shortest Paths.

3.1The General Method

Definition:
Greedy technique is a general algorithm design strategy, built on following elements:
• configurations: different choices, values to find
• objective function: some configurations to be either maximized or minimized

The method:
• Applicable to optimization problems ONLY
• Constructs a solution through a sequence of steps
• Each step expands a partially constructed solution so far, until a complete solution
to the problem is reached.
On each step, the choice made must be
• Feasible: it has to satisfy the problem‘s constraints
• Locally optimal: it has to be the best local choice among all feasible choices
available on that step
• Irrevocable: Once made, it cannot be changed on subsequent steps of the
algorithm

NOTE:
• Greedy method works best when applied to problems with the greedy-choice
property
• A globally-optimal solution can always be found by a series of local
improvements from a starting configuration.

Greedy method vs. Dynamic programming method:

• LIKE dynamic programming, greedy method solves optimization problems.
• LIKE dynamic programming, greedy method problems exhibit optimal
substructure
• UNLIKE dynamic programming, greedy method problems exhibit the greedy
choice property -avoids back-tracing.

Applications of the Greedy Strategy:

27
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

• Optimal solutions:
Change making
Minimum Spanning Tree (MST)
Single-source shortest paths
Huffman codes
• Approximations:
Traveling Salesman Problem (TSP)
Fractional Knapsack problem

3.2 Knapsack problem

• One wants to pack n items in a luggage
• The ith item is worth vi dollars and weighs wi pounds
• Maximize the value but cannot exceed W pounds
• vi , wi, W are integers
• 0-1 knapsack  each item is taken or not taken
• Fractional knapsack  fractions of items can be taken
• Both exhibit the optimal-substructure property
• 0-1: If item j is removed from an optimal packing, the remaining packing is an optimal
packing with weight at most W-wj
• Fractional: If w pounds of item j is removed from an optimal packing, the remaining
packing is an optimal packing with weight at most W-w that can be taken from other n-1
items plus wj – w of item j
Greedy Algorithm for Fractional Knapsack problem
• Fractional knapsack can be solvable by the greedy strategy
• Compute the value per pound vi/wi for each item
• Obeying a greedy strategy, take as much as possible of the item with the greatest value per
pound.
• If the supply of that item is exhausted and there is still more room, take as much as
possible of the item with the next value per pound, and so forth until there is no more
room
• O(n lg n) (we need to sort the items by value per pound)
O-1 knapsack is harder
• knapsack cannot be solved by the greedy strategy

28
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

• Unable to fill the knapsack to capacity, and the empty space lowers the effective value per
pound of the packing
• We must compare the solution to the sub-problem in which the item is included with the
solution to the sub-problem in which the item is excluded before we can make the choice

3.3 Job sequencing with deadlines

The problem is stated as below.
• There are n jobs to be processed on a machine.
• Each job i has a deadline di≥ 0 and profit pi≥0 .
• Pi is earned iff the job is completed by its deadline.
• The job is completed if it is processed on a machine for unit time.
• Only one machine is available for processing jobs.
• Only one job is processed at a time on the machine
• A feasible solution is a subset of jobs J such that each job is completed by its deadline.
• An optimal solution is a feasible solution with maximum profit value.
Example : Let n = 4, (p1,p2,p3,p4) = (100,10,15,27), (d1,d2,d3,d4) = (2,1,2,1)

29
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

• Consider the jobs in the non increasing order of profits subject to the constraint that the resulting
job sequence J is a feasible solution.
• In the example considered before, the non-increasing profit vector is
(100 27 15 10) (2 1 2 1)
p1 p 4 p3 p2 d1 d d3 d2
J = { 1} is a feasible one
J = { 1, 4} is a feasible one with processing sequence ( 4,1)
J = { 1, 3, 4} is not feasible
J = { 1, 2, 4} is not feasible
J = { 1, 4} is optimal

Theorem: Let J be a set of K jobs and

Σ = (i1,i2,….ik) be a permutation of jobs in J such that di1 ≤ di2 ≤…≤ dik.
• J is a feasible solution iff the jobs in J can be processed in the order Σ without violating any
deadly.
Proof:
• By definition of the feasible solution if the jobs in J can be processed in the order without
violating any deadline then J is a feasible solution.

30
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

• So, we have only to prove that if J is a feasible one, then Σ represents a possible order in which
the jobs may be processed.
• Suppose J is a feasible solution. Then there exists Σ1 = (r1,r2,…,rk) such that
drj ≥ j, 1 ≤ j <k
i.e. dr1 ≥1, dr2 ≥ 2, …, drk ≥ k.
each job requiring an unit time.

• Σ = (i1,i2,…,ik) and Σ1 = (r1,r2,…,rk)

• Assume Σ 1 ≠ Σ. Then let a be the least index in which Σ 1 and Σ differ. i.e. a is such that ra ≠ ia.
• Let rb = ia, so b > a (because for all indices j less than a rj = ij).
• In Σ 1 interchange ra and rb.
• Σ = (i1,i2,… ia ib ik ) [rb occurs before ra
• in i1,i2,…,ik]
• Σ 1 = (r1,r2,… ra rb … rk )
• i1=r1, i2=r2,…ia-1= ra-1, ia ≠ rb but ia = rb
• We know di1 ≤ di2 ≤ … dia ≤ dib ≤… ≤ dik.
• Since ia = rb, drb ≤ dra or dra ≥ drb.
• In the feasible solution dra ≥ a drb ≥ b
• So if we interchange ra and rb, the resulting permutation Σ11= (s1, … sk) represents an order with
the least index in which Σ11 and Σ differ is incremented by one.
• Also the jobs in Σ11 may be processed without violating a deadline.
• Continuing in this way, Σ1 can be transformed into Σ without violating any deadline.
• Hence the theorem is proved
GREEDY ALGORITHM FOR JOB SEQUENSING WITH DEADLINE

Procedure greedy job (D, J, n) J may be represented by

// J is the set of n jobs to be completed // one dimensional array J (1: K)
// by their deadlines // The deadlines are
J {1} D (J(1)) ≤ D(J(2)) ≤ .. ≤ D(J(K))
for I  2 to n do To test if JU {i} is feasible,

31
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

If all jobs in JU{i} can be completed we insert i into J and verify

by their deadlines D(J®) ≤ r 1 ≤ r ≤ k+1
then J  JU{I}
end if
repeat
end greedy-job
Procedure JS(D,J,n,k)
// D(i) ≥ 1, 1≤ i ≤ n are the deadlines //
// the jobs are ordered such that //
// p1 ≥ p2 ≥ ……. ≥ pn //
// in the optimal solution ,D(J(i) ≥ D(J(i+1)) //
// 1 ≤ i ≤ k //
integer D(o:n), J(o:n), i, k, n, r
D(0) J(0)  0
// J(0) is a fictious job with D(0) = 0 //
K1; J(1) 1 // job one is inserted into J //
for i 2 to do // consider jobs in non increasing order of pi //
// find the position of i and check feasibility of insertion //
r k // r and k are indices for existing job in J //
// find r such that i can be inserted after r //
while D(J(r)) > D(i) and D(i) ≠ r do
// job r can be processed after i and //
// deadline of job r is not exactly r //
r r-1 // consider whether job r-1 can be processed after i //
repeat
if D(J(r)) ≥ d(i) and D(i) > r then
// the new job i can come after existing job r; insert i into J at position r+1 //
for I  k to r+1 by –1 do
J(I+1) J(l) // shift jobs( r+1) to k right by//
//one position //
repeat

32
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

if D(J(r)) ≥ d(i) and D(i) > r then

// the new job i can come after existing job r; insert i into J at position r+1 //
for I  k to r+1 by –1 do
J(I+1) J(l) // shift jobs( r+1) to k right by//
//one position //
Repeat
COMPLEXITY ANALYSIS OF JS ALGORITHM
• Let n be the number of jobs and s be the number of jobs included in the solution.
• The loop between lines 4-15 (the for-loop) is iterated (n-1)times.
• Each iteration takes O(k) where k is the number of existing jobs.
∴ The time needed by the algorithm is 0(sn) s ≤ n so the worst case time is 0(n2).
If di = n - i+1 1 ≤ i ≤ n, JS takes θ(n2) time
D and J need θ(s) amount of space.
3.4 Minimum-Cost Spanning Trees
Spanning Tree
Spanning tree is a connected acyclic sub-graph (tree) of the given graph (G) that includes
all of G‘s vertices

Example: Consider the following graph

1 b
a

5 2
d

c 3

The spanning trees for the above graph are as follows:

1 1
1 b
b b
a a
a 2
5 2 d
5 d
3 c c
d 3
c
Weight (T2) = 8 Weight (T3) = 6
Weight (T1) = 9

33
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

Minimum Spanning Tree (MST)

Definition:
MST of a weighted, connected graph G is defined as: A spanning tree of G with
minimum total weight.
Example: Consider the example of spanning tree:
For the given graph there are three possible spanning trees. Among them the spanning
tree with the minimum weight 6 is the MST for the given graph

Question: Why can‘t we use BRUTE FORCE method in constructing MST ?

Answer: If we use Brute force method-
• Exhaustive search approach has to be applied.
• Two serious obstacles faced:
1. The number of spanning trees grows exponentially with graph size.
2. Generating all spanning trees for the given graph is not easy.
MST Applications:
• Network design.
Telephone, electrical, hydraulic, TV cable, computer, road
• Approximation algorithms for NP-hard problems.
Traveling salesperson problem, Steiner tree
• Cluster analysis.
• Reducing data storage in sequencing amino acids in a protein
• Learning salient features for real-time face verification
• Auto config protocol for Ethernet bridging to avoid cycles in a network, etc
3.5 Prim’s Algorithm
Some useful definitions:
• Fringe edge: An edge which has one vertex is in partially constructed tree Ti and
the other is not.
• Unseen edge: An edge with both vertices not in Ti

Algorithm:
ALGORITHM Prim (G)
//Prim‘s algorithm for constructing a MST
//Input: A weighted connected graph G = { V, E }
//Output: ET the set of edges composing a MST of G
// the set of tree vertices can be initialized with any vertex
VT → { v0}
ET → Ø
for i→ 1 to |V| - 1 do
Find a minimum-weight edge e* = (v*, u*) among all the edges (v, u) such
that v is in VT and u is in V - VT
VT → VT U { u*}

34
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

ET → ET U { e*}
return ET
STEP 1: Start with a tree, T0, consisting of one vertex
STEP 2: ―G row‖ tree one vertex/edge at a time
• Construct a series of expanding sub-trees T1, T2, … Tn-1.
• At each stage construct Ti + 1 from Ti by adding the minimum weight edge
connecting a vertex in tree (Ti) to one vertex not yet in tree, choose from
“fringe” edges (this is the “greedy” step!)
Algorithm stops when all vertices are included

Example:
Apply Prim‘s algorithm for the following graph to find MST.

1
b c
3 4 4 6

a 5 f 5
d
2
6 8
e

Solution:

Tree Remaining Graph

vertices vertices
b(a,3) b
c(-,∞) 3
a ( -, - ) d(-,∞)
e(a,6) a
f(a,5)

1
c(b,1) b c
3
d(-,∞)
b ( a, 3 )
e(a,6) a
f(b,4)

1 c
b
d(c,6) 3
c ( b, 1 ) e(a,6) 4
f(b,4)
a f

35
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

1
b c
3 4

d(f,5) a f
f ( b, 4)
e(f,2)
2

1
b c
3 4

e ( f, 2) d(f,5) a f 5
d
2

Algorithm stops since all vertices

are included.
d( f, 5)
The weight of the minimum spanning
tree is 15

Efficiency:
Efficiency of Prim‘s algorithm is based on data structure used to store priority queue.
• Unordered array: Efficiency: Θ(n2)
• Binary heap: Efficiency: Θ(m log n)
• Min-heap: For graph with n nodes and m edges: Efficiency: (n + m) log n

Conclusion:
• Prim‘s algorithm is a ―vertex based algorithm‖
• Prim‘s algorithm ― Needs priority queue for locating the nearest vertex.‖ The
choice of priority queue matters in Prim implementation.
o Array - optimal for dense graphs
o Binary heap - better for sparse graphs
o Fibonacci heap - best in theory, but not in practice

36
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

3.6 Kruskal’s Algorithm

Algorithm:

ALGORITHM Kruskal (G)

//Kruskal‘s algorithm for constructing a MST
//Input: A weighted connected graph G = { V, E }
//Output: ET the set of edges composing a MST of G

Sort E in ascending order of the edge weights

// initialize the set of tree edges and its size

ET→Ø
edge_counter →0

//initialize the number of processed edges

K →0
while edge_counter < |V| - 1
k→k + 1
if ET U { ei k} is acyclic
ET →ET U { ei k }
edge_counter →edge_counter + 1
return ET

The method:
STEP 1: Sort the edges by increasing weight
STEP 2: Start with a forest having |V| number of trees.
STEP 3: Number of trees are reduced by ONE at every inclusion of an edge
At each stage:
• Among the edges which are not yet included, select the one with minimum
weight AND which does not form a cycle.
• the edge will reduce the number of trees by one by combining two trees of
the forest

Algorithm stops when |V| -1 edges are included in the MST i.e : when the number of
trees in the forest is reduced to ONE.

37
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

Example:
Apply Kruskal‘s algorithm for the following graph to find MST.

1
b c
3 4 4 6

a 5 f 5
d
2
6 8
e
Solution:
The list of edges is:
Edge ab af ae bc bf cf cd df de ef
Weight 3 5 6 1 4 4 6 5 8 2

Sort the edges in ascending order:

Edge bc ef ab bf cf af df ae cd de
Weight 1 2 3 4 4 5 5 6 6 8

1
bc
Edge b c
1
Weight a
f
d
Insertion
YES
status
Insertion e
1
order

ef 1
Edge b c
2
Weight a f d
Insertion
YES
status 2
Insertion e
2
order

38
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

ab 1
Edge 3 b c
3
Weight a f d
Insertion
YES
status 2
Insertion e
3
order

bf 1
Edge 3 b c
4
Weight a 4 f d
Insertion
YES
status 2
Insertion e
4
order

Edge cf
Weight 4
Insertion
NO
status
Insertion
-
order

Edge af
Weight 5
Insertion
NO
status
Insertion
-
order

df 1
Edge
3 b c
5
Weight
4
Insertion a f d
YES
status 5
2
Insertion
5 e
order
Algorithm stops as |V| -1 edges are included in the MST

39
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

Efficiency:
Efficiency of Kruskal‘s algorithm is based on the time needed for sorting the edge
weights of a given graph.
• With an efficient sorting algorithm: Efficiency: Θ(|E| log |E| )

Conclusion:
• Kruskal‘s algorithm is an ―e
dge based algorithm‖
• Prim‘s algorithm with a heap is faster than Kruskal‘s algorithm.
3.7 Single Source Shortest Paths.

Some useful definitions:

• Shortest Path Problem: Given a connected directed graph G with non-negative
weights on the edges and a root vertex r, find for each vertex x, a directed path P
(x) from r to x so that the sum of the weights on the edges in the path P (x) is as
small as possible.
Algorithm
• By Dutch computer scientist Edsger Dijkstra in 1959.
• Solves the single-source shortest path problem for a graph with nonnegative edge
weights.
• This algorithm is often used in routing.
E.g.: Dijkstra's algorithm is usually the working principle behind link-state
routing protocols
ALGORITHM Dijkstra(G, s)
//Input: Weighted connected graph G and source vertex s
//Output: The length Dv of a shortest path from s to v and its penultimate vertex Pv for
every vertex v in V

//initialize vertex priority in the priority queue

Initialize (Q)
for every vertex v in V do
Dv→∞ ; Pv→null // Pv , the parent of v
insert(Q, v, Dv) //initialize vertex priority in priority queue
ds→0
//update priority of s with ds, making ds, the minimum
Decrease(Q, s, ds)

VT→0

40
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

for i→0 to |V| - 1 do

u*→DeleteMin(Q)
//expanding the tree, choosing the locally best vertex
VT→VT U {u*}
for every vertex u in V – VT that is adjacent to u* do
if Du* + w (u*, u) < Du
Du→Du + w (u*, u); Pu u*
Decrease(Q, u, Du)
The method
Dijkstra‘s algorithm solves the single source shortest path problem in 2 stages.
Stage 1: A greedy algorithm computes the shortest distance from source to all other
nodes in the graph and saves in a data structure.
Stage 2 : Uses the data structure for finding a shortest path from source to any vertex v.
• At each step, and for each vertex x, keep track of a “distance” D(x)
and a directed path P(x) from root to vertex x of length D(x).
• Scan first from the root and take initial paths P( r, x ) = ( r, x ) with
D(x) = w( rx ) when rx is an edge,
D(x) = ∞ when rx is not an edge.
For each temporary vertex y distinct from x, set
D(y) = min{ D(y), D(x) + w(xy) }

Example:
Apply Dijkstra‘s algorithm to find Single source shortest paths with vertex a as the
source.
1
b c
3 4 4 6

a 5 f 5
d
2
6 8
e

Solution:
Length Dv of shortest path from source (s) to other vertices v and Penultimate vertex Pv
for every vertex v in V:
Da = 0 , Pa = null
Db = ∞ , Pb = null
Dc = ∞ , Pc = null
Dd = ∞ , Pd = null
De = ∞ , Pe = null
Df = ∞ , Pf = null

41
Downloaded by Shubham Sanodiya ([email protected])
 lOMoARcPSD|45122995

Tree RemainingDistance & Path Graph

vertices vertices vertex
Da = 0 Pa = a
b ( a , 3D)b = 3 Pb = [ a, b ] b
c ( - , ∞Dc
) = ∞ Pc = null 3
a ( -, 0 ) d ( - , ∞ ) = ∞ Pd = null
Dd a
e ( a , 6De
) = 6 Pe = [ a, e ]
f(a,5) =5
Df Pf = [ a, f ]

Da = 0 Pa = a 1
c ( b , 3+1Db)= 3 Pb = [ a, b ] b c
3
d ( - , ∞Dc) = 4 Pc = [a,b,c]
b ( a, 3 )
e ( a , 6Dd) = ∞ Pd = null a
f ( a , 5De
) = 6 Pe = [ a, e ]
Df = 5 Pf = [ a, f ]
Da = 0 Pa = a
Db = 3 Pb = [ a, b ]
d ( c , 4+6 ) 5
Dc = 4 Pc = [a,b,c]
c ( b, 4 ) e ( a , 6)Dd=10 a f
Pd = [a,b,c,d]
f(a,5)
De = 6 Pe = [ a, e ]
Df = 5 Pf = [ a, f ]
Da = 0 Pa = a
Db = 3 Pb = [ a, b ]
Dc = 4 Pc = [a,b,c] a
d ( c , 10D)d =10 Pd = [a,b,c,d]
f ( a, 5) 6
e ( a , 6De
) = 6 Pe = [ a, e ]
e
Df = 5 Pf = [ a, f ]

Da = 0 Pa = a 1
Db = 3 Pb = [ a, b ] b c
Dc = 4 Pc = [a,b,c]
e ( a, 6) d ( c, 10Dd=10
) Pd = [a,b,c,d] 3 6
De = 6 Pe = [ a, e ] d
Df = 5 Pf = [ a, f ] a

Algorithm stops since no

d( c, 10)
edges to scan

Conclusion:
• Doesn‘t work with negative weights
• Applicable to both undirected and directed graphs
• Use unordered array to store the priority queue: Efficiency = Θ(n2)
• Use min-heap to store the priority queue: Efficiency = O(m log n)

42
Downloaded by Shubham Sanodiya ([email protected])