Data Structures and Algorithm

Prepared by

Mrs.P.Anusha M.Sc(IT).,M.Phil.,D.P.T.T.,(Ph.D).,
Assistant professor,
Department of Information Technology,
Bon secours college for women,
Thanjavur.
GREEDY METHOD
 Greedy Method

• General Approach
• Given a set of n inputs
• Find a subset called feasible solution of the n inputs
subject to some constraints and satisfying a given
objective function
• If the objective function is maximized or minimized the
feasible solution is optimal
• It is locally optimal method
Components of Greedy Algorithm
Greedy algorithms have the following five components −
• A candidate set − A solution is created from this set.
• A selection function − Used to choose the best candidate
to be added to the solution.
• A feasibility function − Used to determine whether a
candidate can be used to contribute to the solution.
• An objective function − Used to assign a value to a
solution or a partial solution.
• A solution function − Used to indicate whether a complete
solution has been reached.
Greedy method control Abstraction for the subset paradigm
Algorithm
• Step 1: Choose an input from the input set, based on some
criterion. If no more input exit.
• Step 2 : Check whether the chosen input yields to a feasible
solution. If no, discard the input and go to step 1
• Step 3 : Include the input into the solution vector and
update the objective function. Go to step 1.
 Optimal Storage on Tapes
• There are n programs that are to be stored on a computer tape
of length L. Associated with each program i is length Li
• Assume the tape is initially positioned at the front. If the
programs are stored in the order I = i1,i2…in the time tj needed

to retrieve program ij
• If all programs are retrieved equally often, then the
Mean Retrieval Time (MRT) =
• This problem fits the ordering paradigm. Minimizing the MRT
is equivalent to minimizing
• d(I) =
Example:
• Let n = 3, (L1, L2, L3) = (5, 10, 3) 6 possible orderings. The
optimal is 3,1,2.
Assigning programs to tapes
 Job Sequencing with Deadlines
Problem Statement
• In job sequencing problem, the objective is to find a sequence of
jobs, which is completed within their deadlines and gives
maximum profit.
Solution
• Let us consider, a set of n given jobs which are associated with
deadlines and profit is earned, if a job is completed by its deadline.
• These jobs need to be ordered in such a way that there is maximum
profit.
• It may happen that all of the given jobs may not be completed
within their deadlines.
• Assume, deadline of ith job Ji is di and the profit received from

this job is pi.

• Hence, the optimal solution of this algorithm is a feasible
solution with maximum profit.
• Thus, D(i) > 0 for 1⩽i⩽n.
• Initially, these jobs are ordered according to profit,
• i.e. p1⩾ p2⩾ p3⩾...⩾ pn
Analysis
• In this algorithm, we are using two loops, one is within another.
Hence, the complexity of this algorithm is O(n2).

Example
• Let us consider a set of given jobs as shown in the following table.
• We have to find a sequence of jobs, which will be completed within
their deadlines and will give maximum profit.
• Each job is associated with a deadline and profit.

Job J1 J2 J3 J4 J5
Deadline 2 1 3 2 1
Profit 60 100 20 40 20
Solution
• To solve this problem, the given jobs are sorted according to their
profit in a descending order.
• Hence, after sorting, the jobs are ordered as shown in the
following table.
Job J2 J1 J4 J3 J5
Deadline 1 2 2 3 1
Profit 100 60 40 20 20
• From this set of jobs, first we select J2, as it can be completed
within its deadline and contributes maximum profit.
• Next, J1 is selected as it gives more profit compared to J4.

• In the next clock, J4 cannot be selected as its deadline is over,

hence J3 is selected as it executes within its deadline.

• The job J5 is discarded as it cannot be executed within its deadline.

• Thus, the solution is the sequence of jobs (J2, J1, J3), which are
being executed within their deadline and gives maximum profit.
• Total profit of this sequence is 100 + 60 + 20 = 180.
 Optimal Merge Pattern
Problem Statement
• Merge a set of sorted files of different length into a single
sorted file.
• We need to find an optimal solution, where the resultant file
will be generated in minimum time.
• If the number of sorted files are given, there are many ways
to merge them into a single sorted file. This merge can be
performed pair wise. Hence, this type of merging is called
as 2-way merge patterns.
• As, different pairings require different amounts of time, in
this strategy we want to determine an optimal way of
merging many files together.
• At each step, two shortest sequences are merged.
• To merge a p-record file and a q-record file requires
possibly p + q record moves, the obvious choice being,
merge the two smallest files together at each step.
• Two-way merge patterns can be represented by binary merge
trees. Let us consider a set of n sorted files {f1, f2, f3, …, fn}.
• Initially, each element of this is considered as a single node
binary tree.
• To find this optimal solution, the following algorithm is used.
• At the end of this algorithm, the weight of the root node
represents the optimal cost.
Example
• Let us consider the given files, f1, f2, f3, f4 and f5 with 20,
30, 10, 5 and 30 number of elements respectively.
• If merge operations are performed according to the
provided sequence, then
• M1 = merge f1 and f2 => 20 + 30 = 50

• M2 = merge M1 and f3 => 50 + 10 = 60

• M3 = merge M2 and f4 => 60 + 5 = 65

• M4 = merge M3 and f5 => 65 + 30 = 95

• Hence, the total number of operations is
50 + 60 + 65 + 95 = 270
• Now, the question arises is there any better solution?
• Sorting the numbers according to their size in an
ascending order, we get the following sequence −
• f4, f3, f1, f2, f5
• Hence, merge operations can be performed on this
sequence
• M1 = merge f4 and f3 => 5 + 10 = 15

• M2 = merge M1 and f1 => 15 + 20 = 35

• M3 = merge M2 and f2 => 35 + 30 = 65

• M4 = merge M3 and f5 => 65 + 30 = 95

• Therefore, the total number of operations is
15 + 35 + 65 + 95 = 210
• In this context, we are now going to solve the problem
using this algorithm.
Initial Set

Step-1
Step-2

Step-3
 Step-4

• Hence, the solution takes 15 + 35 + 60 + 95 = 205 number

of comparisons.
Thank you