Design and Analysis of Algorithm

S.K.P.
Engineering College, Tiruvannamalai IV SEM
SKP Engineering College

Tiruvannamalai – 606611
A Course Material
On
Design and Analysis of Algorithm
By
L.Sankaran
Assistant Professor
Computer Science and Engineering Department
Computer Science Engineering Department 1 Design and Analysis of Algorithm

S.K.P. Engineering College, Tiruvannamalai IV SEM
Quality Certificate
This is to Certify that the Electronic Study Material
Subject Code: CS6402
Subject Name: Design and Analysis of Algorithms
Year/Sem:II/IV
Being prepared by me and it meets the knowledge requirement of the University

curriculum.
Signature of the Author
Name: L.Sankaran
Designation: Assistant Professor
This is to certify that the course material being prepared by Mr. L.Sankaran is of the
adequate quality. He has referred more than five books and one among them is from
abroad author.
Signature of HD Signature of the Principal
Name: K.Baskar Name: Dr.V.Subramania Bharathi
Seal: Seal:

CS6402 DESIGN AND ANALYSIS OF ALGORITHMS LTPC3003

OBJECTIVES:
The student should be made to:
 Learn the algorithm analysis techniques.
 Become familiar with the different algorithm design techniques.
 Understand the limitations of Algorithm power.
UNITI INTRODUCTION 9
Notion of an Algorithm – Fundamentals of Algorithmic Problem Solving – Important
Problem Types – Fundamentals of the Analysis of Algorithm Efficiency – Analysis
Framework – Asymptotic Notations and its properties – Mathematical analysis for
Recursive and Non-recursive algorithms.
UNIT II BRUTE FORCE AND DIVIDE-ANCONQUER 9

Brute Force – Closest-Pair and Convex-Hull Problems-Exhaustive Search – Traveling
Salesman Problem – Knapsack Problem – Assignment problem. Divide and conquer
methodology – Merge sort – Quick sort – Binary search – Multiplication of Large
Integers – Strassen‘s Matrix Multiplication-Closest-Pair and Convex-Hull Problems.
UNIT III DYNAMIC PROGRAMMING AND GREEDY TECHNIQUE 9

Computing a Binomial Coefficient – Warshall‘s and Floyd‘ algorithm – Optimal Binary
Search Trees – Knapsack Problem and Memory functions. Greedy Technique– Prim‘s
algorithm- Kruskal‘s Algorithm- Dijkstra‘s Algorithm-Huffman Trees.
UNITIV ITERATIVIE IMPROVEMENT 9

The Simplex Method-The Maximum-Flow Problem – Maximm Matching in Bipartite
Graphs- The Stable marriage Problem.
UNIT V COPING WITH THE LIMITATIONS OF ALGORITHM POWER 9

Limitations of Algorithm Power-Lower-Bound Arguments-Decision Trees-P, NP and NP-
Complete Problems–Coping with the Limitations – Backtracking – n-Queens problem –
Hamiltonian Circuit Problem – Subset Sum Problem-Branch and Bound – Assignment
problem – Knapsack Problem – Traveling Salesman Problem- Approximation
Algorithms for NP – Hard Problems – Traveling Salesman problem – Knapsack
problem.
TOTAL: 45 PERIODS

OUTCOMES:
At the end of the course, the student should be able to:
 Design algorithms for various computing problems.
 Analyze the time and space complexity of algorithms.
 Critically analyze the different algorithm design techniques for a given problem.
 Modify existing algorithms to improve efficiency.
TEXT BOOK:
1. Anany Levitin, ―Introduction to the Design and Analysis of Algorithms‖, Third Edition,
Pearson Education, 2012.
REFERENCES:
1. Thomas H.Cormen, Charles E.Leiserson, Ronald L. Rivest and Clifford Stein,
―Introduction to Algorithms‖, Third Edition, PHI Learning Private Limited, 2012.
2. Alfred V. Aho, John E. Hopcroft and Jeffrey D. Ullman, ―Data Structures and
Algorithms‖, Pearson Education, Reprint 2006.
3. Donald E. Knuth, ―The Art of Computer Programming‖, Volumes 1& 3 Pearson
Education, 2009. Steven S. Skiena, ―The Algorithm Design Manual‖, Second Edition,
Springer, 2008.
4. http://nptel.ac.in/

CONTENTS
S.No Particulars Page
1 Unit – I 7
2 Unit – II 40
3 Unit – III 88
4 Unit – IV 122
5 Unit – V 160

Prerequisite
Programming data structure I (CS 6202), Programming data structure II(CS 6301). This
class assumes familiarity with asymptotic analysis (Big-O, etc.), recurrence relations
and the correct implementation of basic algorithms. Students without the required
background may struggle to keep up with the lectures and assignments.

Unit – I
Introduction
Part – A
1. Define an algorithm.[ CO1 - L1 - Nov/Dec 2014]

An algorithm is a finite set of instructions that, if followed, accomplishes a
particular task. In addition, all algorithms must satisfy the following criteria:
input
Output
Definiteness
Finiteness
Effectiveness.
2. Define Program. [ CO1 - L1 - May/June 2012]

A program is the expression of an algorithm in a programming language.
3. What is performance measurement? [ CO1 - L1 - May/June 2013]

Performance measurement is concerned with obtaining the space and the time
requirements of a particular algorithm.
4. Write the For LOOP general format. [ CO1 – L1 - May/June 2015]
The general form of a for Loop is
For variable := value 1 to value 2
Step do
{ <statement 1>
<statement n >
}
5. What is recursive algorithm? [ CO1 - L1 - Nov/Dec 2014]
Recursive algorithm makes more than a single call to itself is known as recursive
call. An algorithm that calls itself is Direct recursive. Algorithm A is said to be
indeed recursive if it calls another algorithm, which in turn calls A.

6. What is space complexity? [ CO1 - L1 - Nov/Dec 2010]

The space complexity of an algorithm is the amount of memory it needs to run to completion.
7. What is time complexity? [ CO1 - L1 - Nov/Dec 2010]

The time complexity of an algorithm is the amount of time it needs to run to
completion.
8. Give the two major phases of performance evaluation. [ CO1 - L1]

Performance evaluation can be loosely divided into two major phases:
a prior estimates (performance analysis)
a posterior testing (performance measurement)
9. Define input size. [ CO1 - L1]

The input size of any instance of a problem is defined to be the number
of elements needed to describe that instance.
10. Define best-case step count. [ CO1 - L1 - May/June 2010]

The best-case step count is the minimum number of steps that can be
executed for the given parameters.
11. Define worst-case step count. [ CO1 - L1 - Nov/Dec 2010]

The maximum number of steps that can be executed for the given parameters.
12. Define average step count. [ CO1 - L1]

The average step count is the average number of steps executed an instances
with the given parameters.
13. Define the asymptotic notation “Big oh” (0). [ CO1 - L1 - Nov/Dec 2010]
A function t(n) is said to be in O(g(n)) (t(n) Є O(g(n))), if t(n) is bounded above by
constant multiple of g(n) for all values of n, and if there exist a positive constant c
and non negative integer n0 such that
t(n) ≤ c*g(n) for all n ≥ n0.

14. Define the asymptotic notation “Omega” ( Ω ). [ CO1 - L1 - Nov/Dec 2010]

A function t(n) is said to be in Ω(g(n)) (t(n) Є Ω(g(n))), if t(n) is bounded below by
constant multiple of g(n) for all values of n, and if there exist a positive constant c
and non negative integer n0 such that
t(n) ≥ c*g(n) for all n ≥ n0.
15. Define the asymptotic notation “theta” (Θ). [ CO1 - L1 - Nov/Dec 2013]
A function t(n) is said to be in Θ(g(n)) (t(n) Є Θ(g(n))), if t(n) is bounded both above
and below by constant multiple of g(n) for all values of n, and if there exist a
positive constant c1 and c2 and non negative integer n0 such that
C2*g(n) ≤ t(n) ≤ c1*g(n) for all n ≥ n0.

16. What is a Computer Algorithm? [ CO1 - L1]

An algorithm is a sequence of unambiguous instructions for solving a
problem,i.e.,for obtaining a required output for any legitimate input in a finite amount
of time.
17. What are the features of an algorithm? [ CO1 - L1 - May/June 2013]

More precisely, an algorithm is a method or process to solve a problem
satisfying the following properties:
Finiteness-Terminates after a finite number of steps
Definiteness-Each step must be rigorously and unambiguously specified.
Input-Valid inputs must be clearly specified.
Output-Can be proved to produce the correct output given a valid input.
Effectiveness-Steps must be sufficiently simple and basic.
18. Discuss notion of an algorithm. [ CO1 – L2 – Dec 2009 / May 2013]

An algorithm is a sequence of unambiguous instructions for solving a problem in a finite
amount of time.

19. Classify different problem types? [ CO1 – L3 - Nov/Dec 2013]

Sorting
Searching
String Processing
Graph problems
Combinatorial Problems
Geometric problems
Numerical problems
20. What are different algorithm design techniques/strategies?

[ CO1 - L1 - May/June 2014]
Brute force
Divide and conquer
Decrease and conquer
Transform and conquer
Space and time tradeoffs
Greedy approach
Dynamic programming
Backtracking
Branch and bound
21. How the running time of an algorithm is measured?

[ CO1 – H2 - Apr/May 2015]
Unit for measuring the running time is the algorithms basic operation. The running time
is measured by the count of no. of times the basic operations is executed.
Basic operation: the operation that contributes the most to the total running time.
Example: the basic operation is usually the most time-consuming operation in the
algorithm‘s innermost loop.
22. How time efficiency is analyzed? [ CO1 – H1 - Apr/May 2015]

Let cop – execution time of algorithms basic operation on a particular computer.
c(n) – no. of times this operation need to be executed.
T(n) – running time.
Running time is calculated using the formula
T(n) ≈ cop c(n)

23. What are orders of growth? [ CO1 – L1 - Apr/May 2015]
24. What are basic efficiency classes? [ CO1 - L1 - Apr/May 2012]

1 Constant
log n Logarithmic
n Linear
n log n Linearithmic
n2 Quadratic
n3 Cubic
2n Exponential
n! Factorial
25. Give an example for basic operations. [ CO1 - L1 - May/June 2012]

Input size and basic operation examples
Problem Input size measure Basic operation
Key comparison
Searching for key in a Number of list‘s items,
list of n items i.e. n
Multiplication of two Matrix dimensions or

Multiplication of two numbers
matrices total number of elements
Checking primality of a size = number of digits Division

given integer n (in binary representation)
Number of vertices Visiting a vertex

Typical graph problem
and/or edges

26. What are steps processes in algorithmic problem solving?

[ CO1 - L1 – Nov/Dec 2009]
1. Understanding the problem.
2. Ascertaining the capabilities of a computational device.
3. Choosing between exact and approximate problem solving.
4. Deciding on appropriate data structures.
5. Algorithm Design Techniques.
6. Methods of specifying an algorithm
7. Proving an algorithm's correctness.
8. Analysing an algorithm.
9. Coding an algorithm.
27. What do you mean by Amortized Analysis? [ CO1 - L1 - Nov/Dec 2012]

Amortized analysis finds the average running time per operation over a worst case
sequence of operations. Amortized analysis differs from average-case performance in
that probability is not involved; amortized analysis guarantees the time per operation
over worst-case performance.
28. Define order of an algorithm. [ CO1 - L1 - Nov/Dec 2014]

Measuring the performance of an algorithm in relation with the input size n.
29. How is the efficiency of the algorithm defined? [ CO1 - L1 - Nov/Dec 2012]
The efficiency of an algorithm is defined with the components.
Time efficiency -indicates how fast the algorithm runs
Space efficiency -indicates how much extra memory the algorithm needs
30.Write an algorithm that finds the number of binary digits in the binary
representation of a positive decimal integer. [ CO1 - L1 – Apr/May 2015]
Number of major comparisons=⌊log2n⌋+ 1∈log2n.
Algorithm 3: Finding the number of binary digits in the binary representation of a positive
decimal integer.
Algorithm Binary(n)
count:=1;
whilen >1
do

count:=count+ 1;
n:=⌊n/2⌋;
end
return count;
31.Write doun the properties of asymptotic notations.[CO1 - L1 – Apr/May 2015]

The following property is useful in analyzing algorithms that comprise two consecutively
executed parts.
Theorem
If t1(n) O(g1(n)) and t2(n) O(g2(n)) then,
t1(n) + t2(n) (max {g1(n),g2(n)})
Proof
Since t1(n) O(g1(n)), there exist some constant C1 and some non
negative integer n1 such that
t1(n) ≤ C1 (g1(n)) for all n ≥ n1
Since
t2(n) O(g2(n))
t2(n) ≤ C2 (g2(n)) for all n ≥ n2
Let us denote,
C3=max {C1, C2} and
Consider n ≥ max {n1, n2}, so that both the inequalities can be used.
The addition of two inequalities becomes,
t1(n)+ t2(n) ≤ C1 (g1(n))+ C2 (g2(n))
≤ C3 (g1(n))+ C3 (g2(n))
≤ C3 2 max{g1(n), (g2(n))}
Hence,
t1(n) +t2(n) O (max {g1(n),g2(n)}),
with the constants C and n0 required by the definition being 2C3 = 2 max (C1, C2)
and max {n1, n2} respectively.
The property implies that the algorithms overall efficiency will be determined by
the part with a larger order of growth.
(i.e.) its least efficient part is
t1 1(n)) t1(n) +t2(n) O (max {g1(n),g2(n)}) t2
O(g2(n))

PART – B
1. Explain the notion of an algorithm with diagram. [ CO1 – L2 - May 2014]

Definition:An algorithm is a sequence of non ambiguous instructions for solving a problem in
a finite amount of time.Each algorithm is a module, designed to handle specific problem. The
non ambiguity requirement for each step of' an algorithm cannot be compromised.The range
of inputs for which an algorithm works has to be specified carefully.
Characteristics of an algorithm / Features of an Algorithm

The important and prime characteristics of an algorithm are,
Input:Zero or more quantities are externally supplied.
Output:At least one quantity is produced.
Definiteness:Each instruction is clear and unambiguous.
Finiteness:For all cases the algorithm terminates after a finite number of steps.
Efficiency:Every instruction must be very basic.
Writing an algorithm
Algorithm is basically a sequence of instructions written in simple English language.The

algorithm is broadly divided into two sections
Algorithm heading
It consists of name of algorithm, problem description , input

and output.
Algorithm Body
It consists of logical body of the algorithm by making use of

various programming constructs and assignment statement.

Example 1 : Write an algorithm to count the sum of n numbers
Algorithm sum (1, n)

//Problem description : this algorithm is for finding the
//sum of given n numbers
//Input: 1 to n numbers
//Output: the sum of n numbers
Result ← 0
For i 1 to n do
i ← i+1
Result ← result + i
Return result
Example 2: Write an algorithm to check whether given number is even or odd.

Algorithm eventest ( val)
If (val % 2 = 0) then
Write (―given number is even ―)
Else
Write (―given number is odd‖)
Example 3: Write an algorithm for sorting the elements.

Algorithm sort (a, n)
For i 1 to n do
For j i + 1 to n-1 do
If (a[i]>a[j]) then
{
temp ← a[i]
a[i] ←a[j]
a[j] ←temp
}
Write ( ― list is sorted ―)
Example 4: Write an algorithm to find factorial of n number.
Algorithm fact (n)

//Problem description: this algorithm finds the factorial.
//for given number n
//Input : the number n of which the factorial is to be
//calculated.

//Output : factorial value of given n number.

If( n ← 1) then
Return 1
Else
Return n * fact(n-1)
Example 5: Write an algorithm to perform multiplication of two matrices
Algorithm mul (A, b, n)

//Problem description: this algorithm is for computing
//multiplication of two matrices
//Input : the two matrices A, B and order of them as n
//Output : The multiplication result will be in matrix c
For i ← 1 to n do
For j ← 1 to n do
C [i,j] ← 0
For k ← 1 to n do
C[I ,j ] ←c[i, j] +A[i,k]B[k,j]
Implementation of algorithms
An algorithm describes what the program is going to perform. It states some of the
actions to be executed and the order in which these actions are to be executed.
The various steps in developing algorithm are,
1. Finding a method for solving a problem. Every step of an algorithm should be in
a precise and in a clear manner. Pseudo code is also used to describe the
algorithm.
2. The next step is to validate the algorithm. This step includes, all the algorithm
should be done manually by giving the required input, performs the required
steps including in the algorithm and should get the required amount of output in
an finite amount of time.
3. Finally, implement the algorithm in terms of programming language.
Order of an algorithm:The order of an algorithm is a standard notation of an algorithm

that has been developed to represent function that bound the computing time for
algorithms. It is an order notation. It is usually referred as O-notation.

Example
Problem size = 'n'
Algorithm = 'a' for problem size n
The document mechanism execution = Cn2 times
where C – constant
Then the order of the algorithm 'a' = O(n2)
where n2 = Complexity of the algorithm 'a'.
Program:A set of explicit and unambiguous instructions expressed using a

programming languages constructs is called a program.An algorithm can be converted
into a program, using any programming language.
Sno Algorithm Program

1 Algorithm is finite. Program need to be finite.
2 Algorithm is written using natural Programs are written using a specific
language or algorithmic programming language.
language.
Difference between program and algorithm:
Example : Calculating Greatest common Divisor

The Greatest common Divisor (GCD) of two non zero numbers a and b is basically the
largest integer that divides both a and b evenly i.e with a remainder of zero.
GCD using three methods
Euclid's algorithm
Consecutive integer checking algorithm
Finding GCD using repetitive factors
1. Euclid's algorithm to compute Greatest Common Divisor (GCD) of two

non negative integers.
Euclid's algorithm is based on applying related equality
gcd (m, n) = gcd (n, m mod n) until the m and n is equal to 0
Where m mod n is the remainder of the division of m by n
Step 1: Start
Step 2: If n = 0, return the value of m as the answer and stop,
otherwise proceed to step 3.
Step 3: Divide m by n and assign the value of the remainder to r.
Step 4: Assign the value of n to m and the value of r to n. Goto step 2

Step 5: Stop
Example, gcd (60,24) can be computed as follows,

gcd (60,24) gcd (m, n)
m =60, n=24;
m/n = 2 (remainder 12)
n=m=24
r=n=12
gcd (24, 12) m/2 = 2 (remainder 0)
n=m=12
r=n=0
gcd (12, 0) =12
Hence, gcd(60, 24) = gcd(24,l2)=gcd(12,0)=12
2. Consecutive integer checking algorithm

In this method while finding the GCD of a and b we first of all find the minimum value of
them.
Suppose if , value of b is minimum then we start checking the divisibility by each
integer which is lesser than or equal to b.
Example:a = 15 and b =10 then
t= min( 15,10)
since 10 is minimum we will set value of t = 10 initially.
Consecutive integer checking algorithm for computing gcd(m, n)
Step 1: Start
Step 2: Assign the value of mini {m, n} to t
Step 3: Divide m by t. If the remainder of this division is 0, go to step 4,
Otherwise goto step 5.

Step 4: Divide n by t. If the remainder of this division is 0, return the value

of t as the answer and stop. Otherwise proceed to step 5.
Step 5: Decrease the value of t by I. Go to step 3.
Step 6: Stop
Algorithm GCD intcheck (a,b)
t ← min ( a, b)
while (t>=1) do
{
If ( a mod t == 0 AND b mod t == 0) then
Return t
Else
t ← t-1
}
Return 1
2.Explain the Fundamentals of Algorithmic problem solving. [ CO1 – L2 – May

2014]
Sequential steps in designing and analysing an algorithm
Understanding the problem.
Ascertaining the capabilities of a computational device.
Choosing between exact and approximate problem solving.
Deciding on appropriate data structures.
Algorithm Design Techniques.
Proving an algorithm's correctness.
Analysing an algorithm.
Coding and algorithm.

Understanding the problem:

To design an algorithm, understand the problem completely by reading the problem's
description carefully.Read the problem description carefully and clear the
doubts.Specify exactly the range of inputs the algorithm need to handle.Once the
problem is clearly understandable, then determine the overall goals but it should be in a
precise manner.Then divide the problem into smaller problems until they become
manageable size.
Ascertaining the capabilities of a computational device

Sequential Algorithm:
Instructions are executed one after another, one operation at a time.
This is implemented in RAM model.
Parallel Algorithm: Instructions are executed in parallel or concurrently.

Choosing between exact and appropriate problem solving :The next principal
decision is to choose between solving the problem exactly or solving the problem
approximately.The algorithm used to solve the problem exactly called exact
algorithm.The algorithm used to solve the problem approximately is called
approximation algorithm.
Deciding on appropriate data structures

Data structure is important for both design and analysis of algorithms.
Algorithm + Data Structures = Programs.
In Object Oriented Programming, the data structure is important for both design and
analysis of algorithms.
The variability in algorithm is due to the data structure in which the data of the program
are stored such as
How the data are arranged in relation to each other.
Which data are kept in memory
Which data are kept in files and how the files are arranged.
Which data are calculated when needed?
Algorithm Design Techniques:An algorithm design techniques or strategy or

paradigm is general approach to solving problems algorithmically that is applicable to a
variety of problems from different areas of computing.
Proving an Algorithm's correctness
Once an algorithm has been specified, then its correctness must be proved.An
algorithm must yield a required result for every legitimate input in a finite amount
of time.A mathematical induction is a common technique used to prove the
correctness of the algorithm.In mathematical induction, an algorithm's iterations
provide a natural sequence of steps needed for proofs.If the algorithm is found
incorrect, need to redesign it or reconsider other decisions.
Analysing an algorithm
Efficiency of an algorithm is determined by measuring the time, space and amount of
resources, it uses for executing the program.The efficiency of the algorithm is
determined with respect to central processing units time and internal memory.
Coding an Algorithm
Implementing an algorithm correctly is necessary but not sufficient to diminish the

algorithm's power by an inefficient implementation.The standard tricks such as

computing a loop's invariant (an expression that does not change its value) outside
the loop, collecting common sub expressions, replacing expensive operations by
cheaper ones and so on should be known to the programmers such factors can
speed up a program only by a constant factor, whereas a better algorithm can
make adifference in running time by orders of magnitude.Once an algorithm has
been selected, a 10-50% speed up may be worth an effort.An algorithm's optimality
is not about the efficiency of an algorithm but about the complexity of the problem
it solves.
3. Describe the most important problem types. [ CO1 – L2 - May 2012]

Some of the most important problem types are
Sorting
Searching
String Matching (or) String processing
Graph Problems
Combinatorial problems
Geometric problems
Numerical Problems
Sorting:Sorting means arranging the elements in increasing order or in decreasing

order.The sorting can be done on numbers , characters (alphabets), string or
employees record. Many algorithms are used to perform the task of sorting.Sorting is
the operation of arranging the records of a table according to the key value of the each
record.A table of a file is an ordered sequence of records r[l], r[2].. r[n] each containing a
key k[l], k[2]....k[n]. The table is sorted based on the key.
Properties of Sorting Algorithms

The two properties of Sorting Algorithms are
1. Stable
2. In-place
Stable:
A sorting algorithm is called stable, if it preserves the relative order of any two equal
elements in its input.In other words, if an input list contain two equal elements in
positions i and j, where i<j, then in the sorted list they have to be in position i' and j'
respectively, such that i' < j'
In-place
An algorithm is said to be in-place if it does not require extra memory, except, possibly

for a few memory units.

The important criteria for the selection of a sorting method for the given set of data
items are as follows.
1. Programming time of the sorting algorithm.
2. Execution time of the program
3. Memory space needed for the programming environment
The main objectives involved in the design of sorting algorithms are
1. Minimum number of exchanges.
2. Large volume of data blocks movement.
Types of Sorting
The two major classification of sorting methods are
1. Internal Sorting methods
2. External Sorting methods
Internal Sorting
The key principle of internal sorting is that all the data items to be sorted are retained in
the main memory and random access memory.
This memory space can be effectively used to sort the data items.
The various internal sorting methods are
1. Bubble sort
2. Selection sort
3. Shell sort
4. Insertion sort
5. Quick sort
6. Heap sort
External Sorting
The idea behind the external sorting is to move data from secondary storage to mail
memory in large blocks for ordering the data.The most commonly used external sorting
method is merge sort.
Searching
One of the important applications of array is searching,Searching is an activity by which
we can find out the desired element from the list. The element which is to be searched
is called search key.There are many searching algorithm such as sequential search ,
Fibonacci search and more.
Searching in dynamic set of elements

There may be of elements in which repeated addition or deletion of elements occur.

In such a situation searching an element is difficult. To handle such lists supporting data
structures and algorithms are needed to make the list balanced (organized)
String processing
A string is a collection of characters from an alphabet.
Different type of strings are
Text string
Bit string
Text String
It is a collection of letters, numbers and special characters.
Bit String
It is collection of zeros and ones.
Graph Problems
Graph is a collection of vertices and edges. Formally, a graph G={ V, E } is defined by a
pair of two sets.A finite set V of items called Vertices and a set E of pairs of these items
called edges.If the pairs of vertices are ordered, then G is called a directed graph
because every edge is directed.In a directed graph the direction between two nodes are
not same G(V,W)!=G(W,V) If the pair of the vertices are unordered then G is called an
undirected graph.In undirected graph, the edges has no specific direction.The graph
problems involve graph traversal algorithms, shortest path algorithm and topological
sorting and so on. Some graph problems are very hard to solve. For example travelling
salesman problem, graph colouring problems
Combinatorial Problems
The travelling salesman problem and the graph colouring problems are examples of
combinatorial problems.
A combinatorial object such as a permutation a combination or a subset that satisfies
certain constraints and has some desired property such as maximizes a value or
minimizes a cost should be find.
Combinatorial problems are the most difficult problems.
1. As problem size grows the combinatorial objects grow rapidly and reach
to huge value. size.
2. There is no algorithms available which can solve these problems in finite
amount of time
3. Many of these problems fall in the category of unsolvable problem.
Some combinatorial problems can be solved by efficient algorithms.

Geometric Problems
Geometric algorithms deal with geometric objects such as points ,lines and polygons.
The procedure for solving a variety of geometric problems includes the problems of
constructing simple geometric shapes such as triangles, circles and so on.
The two classic problems of computational geometry are the
1. Closest pair problem
2. Convex hull problem
The closest pair problem is self explanatory. Given n points in the plane, find the closest
pair among them.The convex hull problem is used to find the smallest convex polygon
that would include all the points of a given set.
The geometric problems are solved mainly in applications to computer graphics or in
robotics
Numerical problems
Numerical problems are problems that involve mathematical objects of continuous
nature such as solving equations and systems of equations computing definite integrals
evaluating functions and so on.
Most of the mathematical problems can be solved approximate algorithms.
These algorithms require manipulating of the real numbers; hence we may get wrong
output many times.
4. Explain the fundamentals of the analysis framework. [ CO1 – L2 - May/June

2012]
Efficiency of an algorithm can be in terms of time or space. This systematic approach is
modelled by a frame work called as analysis frame work.
Analysis framework
The efficiency of an algorithm can be decided by measuring the performance of an
algorithm. The performance of an algorithm is computed by two factors
 amount of time required by an algorithm to execute
 amount of storage required by an algorithm
Overview
Space complexity
Time complexity
Measuring an Input's size
Measuring Running Time
Orders of Growth

Space complexity
The space complexity can be defined as amount of memory required by an algorithm to
run.To compute the space complexity we use two factors: constant and instance
characteristics.The space requirement S(p) can be given as S(p) = C+ S(p) Where C is
a constant i.e. fixed part and it denotes the space of inputs and outputs.
Time complexity
The time complexity of an algorithm is the amount of computer time required by an
algorithm to run to completion.For instance in multiuser system, executing time depends
on many factors such as
o System load
o Number of other programs running
o Instruction set used
o Speed underlying hardware
o The time complexity is therefore given in term of frequency count
o Frequency count is a count denoting number of times of execution of
statement
Example
For (i=0; i<n; i++)
{
sum = sum + a[i];
}
Statement Frequency count
i=0 1
i<n This statement executes for (n+1) times. When
conditions is true i.e. when i<n is true , the
execution happens to be n times , and the
statement execute once more when i<n is false
i++ n times
sum = sum + a[i] n times
Total 3n + 2
Measuring an Input's size

All algorithms run longer on larger inputs.
Ex: Sorting larger arrays, multiply larger matrices etc.
Investigates an algorithm efficiency as a function of some parameter n indicating the

algorithm input size.
Example:In problem of evaluating a polynomial p(x) = an x n + ….+ a0 of degree n, the

parameter will be the polynomial's degree or the number of its coefficients which is
larger by one than its degree.In spell checking algorithm, If algorithm examines the
individual character of its input, then the size of the input is the no. of characters.If the
algorithm processes the word, the size of the input is the no. of words.
Measuring Running TimeSome units of time measurement such as a second, a

millisecond and so on can be used to measure the running time of a program
implementing the algorithm.
Drawbacks
l. Dependence on the speed of a particular computer
2. Dependence on the quality of a program implementing the algorithm.
3. The compiler used in generating the machine code.
4. The difficulty of clocking the actual running time of the program .
Basic Operation - the operation contributing the most to the total running time, and
compute the number of times the basic operation is executed.
It is not so difficult to identify the basic operation of an algorithm: it is usually the most
time consuming operation in the algorithm's innermost loop.
Example :Most sorting algorithms work by comparing the elements (keys) of a list being
sorted with each other. For such algorithms the basic operation is a Key Comparison.
Problem Input Size Basic operation
statement
Searching a key List of n elements Comparison of key with
element from the every element of list
list of n elements
Performing matrix The two matrixes with Actual multiplication of the
multiplication order n×n elements in the matrices
Computing GCD Two numbers Division
of two numbers
The formula to compute the execution time using basic operation is

. T(n) ≈ Cop C(n)

Where T(n) – running time
C(n) – no. of times this operation is executed.
Cop – execution time of algorithms basic operation.
Orders of Growth
Measuring the performance of an algorithm in relation with the input size n is called order of
growth.
Worst Case, Best Case and Average Case efficiencies

It is reasonable to measure an algorithm's efficiency as a function of a parameter
indicating the size of the algorithm's input.But for many algorithms the running time
depends not only on an input size but also on the specifics of a particular input.
Example:
Sequential Search or Linear Search
ALGORITHM SequentialSearch(A[0..n − 1], K)
//Searches for a given value in a given array by sequential search
//Input: An array A[0..n − 1] and a search key K
//Output: The index of the first element in A that matches K
// or −1 if there are no matching elements
i ←0
while i < n and A[i] _= K do
i ←i + 1
if i < n return i
else return -1
This algorithm searches for a given item using some search key K in a list of 'n' elements by
checking successive elements of the list until a match with the search key is found or the list
is exhausted.The algorithm makes the largest number of key comparisons among all possible
inputs of size n:Cworst(n)=n
Worst case efficiency

The worst case efficiency of an algorithm is its efficiency for the worst case input of size n,
which is an input (or inputs) of size n. For which the algorithm runs the longest among all
possible of that size.The way to determine the worst case efficiency of an algorithm is that:
Analyse the algorithm to see what Kind of inputs yield the largest value of the basic operations
count C(n) among all possible inputs of size n and then compute is w value Cworst = (n).
Best case efficiency

The best case efficiency of an algorithm is its efficiency for the best case input of size n, which
is an input (or inputs) of. size n for which the algorithm runs the fastest among all possible
inputs of that size.
The way to determine the best case efficiency of an algorithm is as follows.
First, determine the kind of inputs of size n.
Then ascertain the value of C(n) on these inputs.
Example: For sequential search, the best case inputs will be lists of size 'n' with their first
elements equal to a search key: Cbest(n) = 1.
Average case efficiency

It yields the necessary information about an algorithm's behaviour on a "typical" or "random"
input. To determine the algorithm's average case efficiency some assumptions about possible
inputs of size 'n'. The average number of key comparisons C avg (n) can be computed as
follows:In case of a successful search the probability of the first match occurring in the
position of the list is p/n for every i. and the number of comparisons made by the algorithm in
such a situation is obviously ‗i‘.In case of an unsuccessful search, the number of comparisons
is 'n' with the probability of such a search being (1-p). Therefore,
Cavg(n)=[1. +2. +......i. +...n. +]+n.(1-p) There may be n elements at

= [1+2+3+....+i+...+n]+n(1-p) which chances of ‘not getting
= +n(1-p) element’ are possible. Hence n .
(1-p)
Cavg(n)= + n(1-p)
Example:
If p = 1 (i.e.) if the search is successful, then the average number of key comparisons
made by sequential search is (n+1)/2.
If p = 0 (i.e.) if the search is unsuccessful, then the average number of key comparisons
will be 'n' because the algorithm will inspect all n elements on all such inputs.
5. Explain the Mathematical analysis for non-recursive algorithm. [ CO1 – L2 –

Nov/Dec2011]
General plan for analyzing efficiency of non-recursive algorithm
1. Decide the input size based on parameter n.
2. Identify the algorithm basic operation(s).
3. Check whether the number of times the basic operation is executed depends on only on
the size of the input.
4. Set up a sum expressing the number of times the algorithm basic operation is excited
5. Simplify the sum using standard formula and rules

Example 1:
Problem for finding the value of the largest element in a list of n numbers
The pseudo code to solving the problem is
ALGORITHM MaxElement(A[0..n-1])
//Problem Description : This algorithm is for finding the
//maximum value element from the array
//Input:An array A[0..n-1] of real numbers
//Output: Returns the largest element from array
Maxval ← A[0]
For i ← 1 to n-1 do Searching the maximum element from an array
{
If ( A[i]>max_value)then
Maxval ← A[i] If any value is large than current
}
Max_ Value then set new Max_value
Return Max_value
by obtained larger value
Mathematical Analysis
Step 1: The input size is the number of elements in the array(ie.),n
Step 2 : The basic operation is comparison in loop for finding larger value
There are two operations in the for loop
1.Comparison operation a[i]->maxval
2.Assignment operation maxval->a[i]
Step 3: The comparison is executed on each repetition of the loop. As the
comparison is made for each value of n there is no need to find best case
worst case and average case analysis.
Step 4: Let C(n) be the number of times the comparison is executed.
The algorithm makes comparison each time the loop executes.
That means with each new value of I the comparison is made.
Hence for i= 1 to n – 1 times the comparison is made . therefore we can
formulate C(n) as
C(n) = one comparison made for each value of i
Step 5 : let us simplify the sum
Thus C(n) =∑
=n-1 θ (n) Using the rule ∑ θ (n)
The frequently used two basic rules of sum manipulation are,

∑ i=C∑ i R1
∑ i+bi)=∑ +∑ I i R2
The two summation formulas are
1. ∑ =u-l+1
Where l≤ u are some lower and upper integer limits S1
2. ∑ =∑ =1+2+…..+n
=n(n+1)/2
=1/2n2 o(n2) S2
Example 2
Element uniqueness problem-check whether all the element in the list are distinct
ALGORITHM UniqueElements(A[0..n-1])
//Checks whether all the elements in a given array are distinct
//Input :An array A[0..n-1]
//Output Returns ‗true‘ if all elements in A are distinct and ‗false‘
//otherwise
for i  to n-2 do
for j i+1 to n-1 do
If any two elements in the array
if a[i] = a[j] then
return false are similar then return .false
else indicating that the array elements
return true are not distinct
Mathematical analysis
Step 1: Input size is n i.e total number of elements in the array A
Step 2: The basic iteration will be comparison of two elements . this
operation the innermost operation in the loop . Hence
if a[i] = a[j] then comparison will be the basic operation .
Step 3 : The number of comparisons made will depend upon the input n .
but the algorithm will have worst case complexity if the same
element is located at the end of the list. Hence the basic operation
depends upon the input n and worst case
Worst case investigation

Step 4: The worst case input is an array for which the number od elements
comparison cworst(n) is the largest among the size of the array.
There are two kinds of worst case inputs, They are
1.Arrays with no equal elements.
2.Arrays in which the last two elements are pair of equal elements.
For the above inputs, one comparison is made for each repetition of the inter most
loop (ie) for each value of the loop's variable 'j' between its limits i+1 and n-1 and this
is repeated limit for each values of the outer loop (ie) for each value of the loop's
variable `i' between 0 and n-2. Accordingly,
C worst (n) = Outer loop × Inner loop
Cworst(n) = ∑ ∑
Step 5: now we will simplify C worst as follows
=∑ Θ∑
=∑
=∑ -∑
Now taking (n-1) as a common factor, we can write
This can be obtained using
formula∑ /2
This can be obtained using formula

= (n-1) ∑
. w
𝑖
Solving this equation we will get

= 2( n-1) (n-1) – (n-2) (n-1)/2 2 0
= ( 2(n 2 – 2n + 1) – (n 2- 3n + 2)) /2 𝑖
= (( n2 – n) / 2
=1/2 n2
 Θ (n2)
We can say that in the worst case the algorithm needs to compare all
n (n – 1 )/2 distinct of its n elements.
Therefore C worst(n)= 1/2n2 € o(n2)

EXAMPLE 3 : Obtaining matrix multiplication

Given two n × n matrices A and B, find the time efficiency of the definition-
based algorithm for computing their product C = AB, where A and B are n
by n (n*n) matrices.
where C[i, j ]= A[i, 0]B[0, j]+ . . . + A[i, k]B[k, j]+ . . . + A[i, n − 1]B[n − 1, j] for every
pair of indices 0 ≤ i, j ≤ n − 1.
b b
00 01
a a a
C= 00 01 03 1 2
b b
1 2 3 × 10 11
a a a
10 11 12 3 4
4 5 6
The formula for multiplication of the above two matrices is
a00 ×b00 + a01 ×b10 + a02 ×b20 a00 ×b01 + a01×b11 + a02×b21
C= a10×b00 + a11×b10 + a12×b20 a10×b01 + a11×b11 + a12×b21
C= 1×1+2×3+3×5 1 × 2 + 2 × 4 + 3× 6
4×1+5×3+6×5 4×2+5×4+6×6
C= 22 28
49 64
Now the algorithm for matrix multiplication is

Step 1: The input‘s size of above algorithm is simply order of matrices i.e n.
Step 2: The basic operation is in the innermost loop and which is
There are two arithmetical operations in the innermost loop here

1. Multiplication
2. Addition
Step 3: The basic operation depends only upon input size. There are no best
case, worst case and average case efficiencies. Hence now we will go
for computing sum. There is just one multiplication which is repeated
no each execution of innermost loop. ( a for loop using variable k ).
Hence we will compute the efficiency for innermost loops.
Step 4: The sum can be denoted by M (n).
M(n) = outermost × inner loop × innermost loop ( 1 execution )
= [for loop using i] × [for loop using j] × [for loop using k] ×
(1 execution)

M(n)= n3
Thus the simplified sum is n3. Thus the time complexity of matrix
multiplication Θ (n3)
Running time of the Algorithm T(n)

The estimation of running time of the algorithm on a particular machine is calculated by
using the product.
T (n) ≈ cmM(n) = cmn3
Where
cm is the time of one multiplication on the machine in question. We would
get a more accurate estimate if we took into account the time spent on the
additions, too:
T (n) ≈ cmM(n) + caA(n) = cmn3 + can3 = (cm + ca)n3
T (n) ≈ cmM(n) = cmn3
where cm is the time of one multiplication on the machine in question. We would get a
more accurate estimate if we took into account the time spent on the additions, too:
Time spend addition CA (n)

The time speed to perform the addition operation is given by
T(n) = caA(n)= ca n3
Where
ca is the time taken to perform the one addition.
Hence the running time of the algorithm is given by
T (n) ≈ cmM(n) + caA(n) = cmn3 + can3 = (cm + ca)n3
The estimation differs only by the multiplication constants and not by the order of
growth.
EXAMPLE 4
The following algorithm finds the number of binary digits in the binary
representation of a positive decimal integer.

Step 1: The input size is n i.e . The positive integer whose binary digit in binary
representation needs to be checked.
Step 2 : The basic operation is denoted by while loop. And it is each time checking
whether n > 1. The while loop will be executed for the number of time at which n>1 is
true . it will be executed once more when n>1 is false . but when n>1 is false the
statements inside while loop wont get executed.
Step 3: The value of n is halved on each repetition of the loop. Hence efficiency
algorithm is equal to log2 n
Step 4: hence total number of times the while loop gets executed is
[log2 n] + 1
Hence time complexity for counting number of bits of given number is Θ
(log2 n). the indicates floor value of log 2 n
6.Derive the worst case analysis of merge sort using suitable illustration. [ CO1
– H3 – Apr/May 2015]
Efficiency of Merge Sort
In merge sort algorithm the two recursive calls are made. Each recursive call focuses on
n/2 elements of the list . After two recursive calls one call is made to combine two
sublist i.e to merge all n elements. Hence we can write recurrence relation as
T(n) = T(n/2) + T(n/2) + cn
T(n/2) = Time taken by left sublist
T(n/2) = time taken by right sublist
T(n) = time taken for combining two sublists
where n> 1 T (1) = 0
The time complexity of merge sort can be calculated using two methods
Master theorem
Substitution method

Master theorem
Let , the recurrence relation for merge sort is
T(n) = T(n/2) + T(n/2) + cn
let
T(n) = aT(n/b) + f(n) be a recurrence relation
i.e. T(n) = 2T(n/2) + cn ------- ( 1 )
T(1) = 0 ----------- (2 )
As per master theorem
T(n) = Θ (n d long n ) if a = b
As equation ( 1),
a =2 , b = 2 and f(n) = cn
and a = bd
i.e 2 = 2`
This case gives us ,
T (n) =Θ (n log2 n)
Hence the average and worst case time complexity of merge sort is
C worst (n) = (n log2 n)
Substitution method
Let, the recurrence relation for merge sort be
T(n) = T(n/2) + T(n/2) + cn for n>1
i.e. T(n) = 2T(n/2) + cn for n>1 ------- (3)
T(1) = 0 -------(4)
Let us apply substitution on equation ( 3) .
Assume n=2k
T(n) = 2T(n/2) + cn
T(n) = 2T(2k/2 ) + c.2k
T(2k) = 2T(2k-1) + c.2k
If k = k-1 then,
T(2k) = 2T(2k-1) + c.2k
T(2k) = 2[2T(2k-2) + c.2k -1] + c.2k
T(2k) = 22 T(2k-2) + 2.c.2k -1 + c .2k
T(2k) = 22 T(2k-2) + 2.c.2k /2 + c.2k
T(2k) = 22 T(2k-2) + c.2k + c.2k
T(2k) = 22 T(2k-2) + 2c .2k
T(2k) = 23 T(2k-3) + 3c .2k
T(2k) = 24 T(2k-4) + 4c .2k
T(2k) = 2k T(2k-k) + k.c.2k

T(2k) = 2k T(20) + k.c.2k

T(2k) = 2k T(1) + k.c.2k -------- (5)
But as per equation (4), T(1) =0
There equation (5) becomes ,
T(2k) = 2k .0 +. k. c . 2k
T(2k) = k. c . 2k
But we assumed n=2k , taking logarithm on both sides.
i.e. log 2 n = k
Therefore T(n) = log 2 n. cn
Therefore T (n) =Θ (n log2 n)
Time complexity of merge sort
Best case Average case Worst case
Θ (n log2 n) Θ (n log2 n) Θ (n log2 n)

Unit – 2
Brute Force And Divide-And-Conquer
Part - A
1.Define Brute Force approach. [ CO2 - L1 - May/June 2014]

Brute Force is a straightforward approach to solve a problem, which is directly based on
the problem statement and definition of the concepts. Brute Force strategy is one of the
easiest approach.
2.What are the types of Brute Force Algorithm? [ CO2 - L1 - May/June 2010]
There are two types of Brute force algorithm. They are Consecutive integer checking
algorithm for computing the greatest common divisor of two integer[gcd(m,n)] Definition
based algorithm for matrix multiplication.
3.What are the Advantages of Brute Force Approach? [ CO2 - L1 – Nov/Dec 2015]
Advantages
A brute Force algorithm can be useful for solving small size instances of a problem.A
brute Force algorithm can serve an important theoretical or educational purpose.The
brute force approach provides reasonable algorithms of atleast some practical value
with no limitation on instance size for sorting, searching, matrix multiplication and string
matching problem.
4.What is Closest-Pair Problem? [ CO2 - L1 - Nov/Dec 2014]

The closest-pair problem calls for finding the two closest points in a set of n points. It is
the simplest of a variety of problems in computational geometry that deals with proximity
of points in the plane or higher-dimensional spaces.
5.What is meant by Convex? [ CO2 - L1]

A set of points (finite or infinite) in the plane is called convex if for any two points p and
q in the set, the entire line segment with the endpoints at p and q belongs to the set.
6.What is meant by convex hull? [ CO2 - L1]

The convex hull of a set S of points is the smallest convex set containing S. (The
―smallest‖ requirement means that the convex hull of S must be a subset of any convex
set containing S.)
7.Define exhaustive search. [ CO2 - L1]

An exhaustive search, also known as generate and test, is a very general problem-
solving technique that consists of systematically enumerating all possible
candidates for the solution and checking whether each candidate satisfies the
problem's statement.
8.What is Travelling Salesman Problem? [ CO2 - L1 - Nov/Dec 2011]

The Travelling Salesman Problem (TSP) is an NP-hard problem in combinatorial
optimization studied in operations research and theoretical computer science. Given a
list of cities and their pairwise distances, the task is to find a shortest possible tour that
visits each city exactly once.
9.Summarize knapsack problem. [ CO2 – L2 – Nov/Dec 2011]

The knapsack problem, another well-known NP-hard problem.The Knapsack problem
is, given n items of known weights w1, . . . , wn and values v1, . . . , vn and a knapsack of
weight capacity W, find the most valuable subset of the items that fits into the
knapsack.
10.Describe assignment problem.[ CO2 – L2]

The assignment problem is one of the fundamental combinatorial optimization problems
in the branch of optimization or operations research in mathematics. It consists of
finding a maximum weight matching in a weighted bipartite graph.
11. Define the divide and conquer method. [ CO2 - L1]

Divide & conquer technique is a top-down approach to solve a problem.
The algorithm which follows divide and conquer technique involves 3 steps:
Divide the original problem into a set of sub problems.
Conquer (or Solve) every sub-problem individually, recursive.
Combine the solutions of these sub problems to get the solution of original problem.
12. What is the binary search? [ CO2 - L1 - May/June 2011]

If ‗q‘ is always chosen such that ‗aq‘ is the middle element (that is, q = [(n+1)/2)],
then the resulting search algorithm is known as binary search.
13. What is the time complexity of Binary search? [ CO2 - L1 - May/June

2011,2012]

Successful searches unsuccessful searches
Θ (1) Θ (log n) Θ (log n) Θ (log n)
Best Average Worst Best ,Average, Worst
14. Define external path length? [ CO2 - L1]

The external path length E, is defines analogously as sum of the distance of all
external nodes from the root.
15. Define internal path length. [ CO2 - L1]

The internal path length ‗I‘ is the sum of the distances of all internal nodes from the
root.
16. Is insertion sort better than the merge sort? [ CO2 – H2]
Insertion sort works exceedingly fast on arrays of less then 16 elements, though for
large ‗n‘ its computing time is O (n2).
17. Write the recurrence relation of divide-and-conquer? [ CO2 - L1 -

May/June 2012]
The recurrence relation is
T( n) = g(n) n is smal T(n1) + T(n2) + T(nk) + f(n) otherwise
Where T(n) is the time for DAndC on any input of size n and g(n) is the time to
compute the answer directly for small inputs.
The function f(n) is the time for dividing P and combining the solutions to subproblems.
18. What are internal nodes? [ CO2 - L1]

The circular node is called the internal nodes.
19. Give the recurrence equation for the worst case behavior of merge sort? [
CO2 - L1 – Nov/Dec 2010]
The recurrence equation for the worst case behavior of merge
sort is T(n) = 2T(n/2) + cn for n>1, c is a constant

Total number of comparison required by the merge sort is Θ(n logn)
20. Find the number of comparisons made by the sequential. [ CO2 - L1 - Nov/Dec
2011]
search in the worst case and best case?
Worst case: The algorithm makes the largest number of key comparisons among all
possible input of size n. Cworst(n)=n
Best Case: The best case inputs will be lists of size n with their first element equal to
search key. Cbest(n)=1
21. Give efficiency analysis of divide and conquer? [ CO2 – H1]

The efficiency of divide and conquer algorithms is given by recurrences of the form.
T(n) = T(n) n=1
aT(n/b) + f(n) n>1
Where a and b are known constants. We assume that T(1) is known and n is a
power of b ( n=bk).
22. What is the idea behind binary search? [ CO2 - L1 - Nov/Dec 2013]
A binary search or half-interval search algorithm finds the position of a specified value
(the input "key") within a sorted array.In each step, the algorithm compares the input
key value with the key value of the middle element of the array. If the keys match, then
a matching element has been found so its index, or position, is returned. Otherwise, if
the sought key is less than the middle element's key, then the algorithm repeats its
action on the sub-array to the left of the middle element or, if the input key is greater, on
the sub-array to the right. If the remaining array to be searched is reduced to zero, then
the key cannot be found in the array and a special "Not found" indication is returned.
23. Give the time efficiency and drawback of merge sort. [ CO2 - L1- Nov/Dec
2013 ]
Refer Class Notes
24. Trace the operation of binary search algorithm for the input –
15, -6, 0, 7, 9, 23, 54, 82, 101, 112, 125, 131, 142, 151, if you

are searching for the element 9. [ CO2 – L3 - Dec 2010]

Input :
15 -6 0 7 9 23 54 82 101 112 125 131 142 151
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Iteration 0:
Left = 0
Right = 13
Mid = (Left + Right) / 2
= (0 + 13) / 2
Mid = 6
Midelement = 54
Search key = 9
Since 9 < 54, search the element 9 in the left of midelement 54.
Iteration 1:
Left = 0
Right = 5
= (0 + 5) / 2
Mid = 2
Midelement = 0
Search key = 9
Since 9 > 0, search the element 9 in the right of midelement 0.
Iteration 2:
Left = 3
Right = 4
= (3 + 4) / 2
Mid = 3
Midelement = 7
Search key = 9
Since 9 > 7, search the element 9 in the right of midelement 7.
Therefore 9 is found in the position 4.
25.Design a brute force algorithm for computing the value of a polynomial

[ CO2 – H3 - Dec 2010]
Problem: Find the value of polynomial
p(x) = anxn + an-1xn-1 +… + a1x1 + a0 at a point x = x0
Algorithm:

x := x0
p := 0.0
for i := n down to 0 do
power := 1
for j := power * x
p := p + a:= 1 to i do
power [i] * power
return p
Efficiency: (n2)
26. Distinguish between sequential and binary search. [ CO2 – L2 – Apr/May 2013]
Sequential technique binary search technique
This is the simple technique of This is the efficient technique of searching

searching an element an element
This technique does not require the list This technique require the list to be sorted.
to be sorted Then only this method is applicable
The worst case time complexity of this The worst case time complexity of this
technique is O(n) technique is O(log n)
Every element of the list may get Only the mid element of the list is
compared with the key element. compared with key element.
27. List out two drawbacks of binary search algorithm.

[ CO2 - L1 – Dec 2007]
In binary search the elements have to be arranged either in ascending or descending
orderEach time the mid elements has to be computed in order to partition the list in two
sub lists
28. Give the control abstraction for divide and conquer.

[ CO2- L1– Dec 2012]
divide_and_conquer ( P )
{

if ( small ( P ) ) // P is very small so that a solution is trivial

return solution ( n );
divide the problem P into k instances P1, P2, ..., Pk;
return ( combine ( divide_and_conquer ( P1 ),
divide_and_conquer ( P2 ),
divide_and_conquer ( Pk ) ) );
}
The solution to the above problem is described by the recurrence,
assuming size of P denoted by n
where f(n) is the time to divide n elements and to combine their solution.
29. What is the necessary precondition for the binary search ? [ CO2 - L1 -
May/June 2015]
For the binary search the list should be sorted either in ascending or descending order
30.Derive complexity of binary search algorithm. ? [CO2 –L2– Apr/ May 2015]
Worst Case Analysis
The worst case includes all arrays that do not contain a search key.
The recurrence relation for
Cworst(n) = Cworst (n/2) + 1, for n > 1 ----- (1)
Time required to one comparison

compare left sublist made with middle element
or right sub list
Cworst(1) = 1 -------- ( 2 )
The above recurrence relation can be solved further .
assume n=2k the equation ( 1 ) becomes
Cworst(2k) = Cworst(2 k /2)+ 1
Cworst(2k) = Cworst(2 k-1)+ 1 ------ ( 3 )
Using backward substation method , we can substitute
Cworst(2k-1) = Cworst(2k-2)+ 1
Then equation (3) becomes
Cworst(2k) = [Cworst( 2 k-2)+ 1] + 1
Cworst(2k) = Cworst( 2 k-2)+ 2
Then

Cworst(2k) = [Cworst( 2 k-3)+1]+ 2

Cworst(2k) =Cworst( 2 k-3)+3
---
---
k k-k
Cworst(2 ) =Cworst( 2 )+k
Cworst(2k) =Cworst( 2 0)+k
Cworst(2k) =Cworst( 1 )+k ----- (4)
But as per equation (2 )
as we have assumed n = 2k taking logarithm (base 2 )on both sides
log 2 n = log 2 2k
log 2 n = k. log 2 2
log 2 n = k(1) therefore log 2 2 =1
therefore k = log 2 n
Cworst(1) = 1 the we get equation ( 4 )
Cworst(2k) = 1 + k
Cworst(n) = 1 + log2n ----- (2)
Cworst(n) = log2n for n>1
The worst case time complexity of binary search is Θ(log2n)
As Cworst(n) = log2n + 1
we can verify equation ( 1) with this value.
Cworst(n) = Cworst[(n/2)] + 1
In equation (1) put n = 2i
L.H.S Cworst(n) = log2n + 1
= log2(2i )+ 1
= log 2 2 + log 2i + 1
= 1+ log 2i + 1
= 2 + log 2i
Cworst(n) =2 + log 2i
R.H.S Cworst(n/2)+1 = log 2(2i/2 )+ 1
= log 2i + 1
= log 2 2i + 1+ 1
= 2 + log 2i
Cworst(n/2) =2 + log 2i
L.H.S = R.H.S
Hence
Cworst(n) = log 2n + 1 and
Cworst(i) = log 2i + 1 are same
Cworst(n) = Ө(log n )

PART – B
1. Discuss in detail about brute force algorithm. [ CO2 – L2 ]

Brute Force is a straightforward approach to solve a problem, which is directly based
on the problem statement and definition of the concepts. Brute Force strategy is one of
the easiest approaches.
Computing an : for a given number a and a non negative integer n , find the
exponentiation as follows
an = a * a* a* ….a* for n times
Computing n! : The n! can be computed as 1 *2 * 3….*n
Performing multiplication of two matrices.
Searching a key value from given list of elements.
Brute Force Algorithm
Two types of Brute force algorithm
1. Consecutive integer checking algorithm for computing the greatest common divisor of
two integer[gcd (m,n)]
2. Definition based algorithm for matrix multiplication.
Advantages of Brute Force Approach
1. It is applicable to a variety of problems.
2. A brute Force algorithm cab be useful for solving small size
instances of a problem.
3. A brute Force algorithm cab be serve an important
theoretical or educational purpose.
4. The brute force approach provides reasonable algorithms of
atleast some practical value with no limitation on instance
size for sorting, searching, matrix multiplication and string
matching problem.
2. Explain the Closest-pair and convex-Hull problems by brute force in detail. [
CO2 – H2 - May 2015]
Closest-Pair Problem
The closest pair problem is – finding the two closest points from the set of n points.
For simplicity the closet pair problem can be considered to be in two dimensional case.
The point is specified by a pair (x,y).hence .hence P=(x,y) is a point on a two
dimensional plan.
The distance between two points is denoted by Euclidean distance.
It is denoted as

where pi and pj are two points for which i<j
The basic operation in above algorithm is computing Euclidian distance between two
points.
Then the basic operation of the algorithm will be squaring a number.
The number of times it will be executed can be computed as follows:
C(n) = ∑ ∑ 2
= 2∑
= 2[(n − 1) + (n − 2) + . . . + 1]
= (n − 1)n ∈ θ(n2).
Of course, speeding up the innermost loop of the algorithm could only decrease the
algorithm‘s running time by a constant factor, but it cannot improve its asymptotic
efficiency class.
Convex-Hull Problem
Definition:
Given a set S { p1, p2 ,p3, …pn} of points in the plan , the convex hull H(S) is the
smallest convex polygon in the plane that contains all of the points of S. the set S is
called as coves set .
A polygon is convex if and only if any two points from the set forming a line
segment with end points entirely within the polygon

(a) Convex sets. (b) Sets that are not convex.
Definition of Convex Hull:

The convex hull of a set S of points is the smallest convex set containing S.
If S is a set of two points its convex hull is the line segment connecting these points
.if S is a set of three points then its convex hull is the triangle
Convex hull problem is the problem of constructing the convex hull for a given set S
of n points

P
P
P
P
P
P P
The points { 1, 2, 3, 4 , 5, 6 } are called extreme points
Example 2:
The convex hull for this set of eight points is the convex polygon with vertices at {p1,
p5, p6, p7, and p3.}
Definition of extreme points

An extreme point of a convex set is a point which is not a middle point of any line
segment with end points in the set Extreme points have several special properties other
points of a convex set do not have. One of them is exploited by the simplex method.
This algorithm solves linear programming problems, which are problems of finding a
minimum or a maximum of a linear function of n variables subject to linear constraints.
Here, however, we are interested in extreme points because their identification solves
the convex-hull problem. Actually, to solve this problem completely, we need to know a
bit more than just which of n points of a given sets are extreme points of the set‘s
convex hull: we need to know which pairs of points need to be connected to form the
boundary of the convex hull.
Note that this issue can also be addressed by listing the extreme points in a
clockwise or a counter clockwise order.
A few elementary facts from analytical geometry are needed to implement this
algorithm.
1. The straight line through two points (x1, y1), (x2, y2) in the
coordinate plane can be defined by the equation
ax + by = c

where a = y2 − y1, b = x1 − x2, c = x1y2 − y1x2.

2. Such a line divides the plane into two half-planes:
for all the points in one of them, ax + by > c,
for all the points in the other, ax + by < c.
For the points on the line itself, of course, ax + by = c.
Thus, to check whether certain points lie on the same side of the line, we can simply
check whether the expression
ax + by = c has the same sign for each of these points.
Time efficiency of this algorithm is in O(n3): for each of n(n − 1)/2 pairs of distinct points,
we may need to find the sign of ax + by – c for each of the other n − 2 points
3. Describe the concept of Exhaustive search with the help of an example. [

CO2 – L2 ]
Exhaustive search is simply a brute-force approach to combinatorial problems.
It suggests generating each and every element of the problem domain, selecting those
of them that satisfy all the constraints, and then finding a desired element.
Three exhaustive search problems:
 The travelling salesman problem,
 The knapsack problem, and
 The assignment problem.
1. Travelling Salesman Problem
The Travelling salesman problem (TSP) has been intriguing researchers for the last
150 years by its seemingly simple formulation, important applications, and interesting
connections to other combinatorial problems. The travelling salesman problem (TSP)
is a famous problem in the graph theory.It can be stated as follows - consider that
there are n cities and travelling salesman has to visit each city exactly once and
has to return to the city from where he has started.To model this problem
weighted graph can be used. The vertices of such graph represent cities and the
edge weight specifies the distances between the cities
This problem can also be started as finding shortest Hamiltonian circuit of the graph.
The shortest Hamiltonian circuit is a cycle in the given graph such that all the vertices
of the graph can be visited only once.And the tour obtained in such a way has
shortest distance.
Example
Consider the graph as given below.This is a weighted graph in which weight along
the edges represent the distances among the cities. We have to find shortest

Hamiltonian circuit i.e. the path in which each city is visited once and returning
to the city from which it has started initially.
2
a b
Tour 5 8 7 3 Length
a -> b -> c -> d -> a I = 2+8+1+7 = 18
a -> b -> d -> c-> a I =c 2+3+1+5d = 11
optimal 1
a-> c -> b -> d -> a I = 5+8+3+7 = 23
a-> c -> d -> b -> a I = 5+1+3+2 = 11
optimal
a-> d ->b -> c -> a I = 7+3+8+5 = 23
a-> d -> c -> b -> a I = 7+1+8+2 = 18
Fig: Solution to a small instance of the travelling salesman
problem by exhaustive search
Thus we have to try each possible path and find the shortest distance which gives
optimal tour.
It is easy to see that a Hamiltonian circuit can also be defined as a sequence of n +
1 adjacent vertices vi0, vi1, . . . , vin−1, vi0, where the first vertex of the sequence is the
same as the last one and all the other n − 1 vertices are distinct
2. Knapsack Problem
This is another popular problem which can be solved using exhaustive search.
It can be stated as follow : suppose that there are n objects from I = 1,2 , 3, …n. each
object I has some weight wi and values associated with each object is vi .
And capacity of knapsack is W. a person has to pickup the most valuable objects to
fill the knapsack to its capacity.
Example:Consider a knapsack instance as follows

The Knapsack capacity W=8
I Wi Vi
1 7 $42
2 3 $12
3 4 $40
4 5 $25
Subset Total Weight Total Value

Nil 0 $0
{1} 7 $42
{2} 3 $12
{3} 4 $40
{4} 5 $25
{1,2} 7+3=10 $42+$12=$54
7+4=11
{1,3} Not feasible
(11>10)
7+5=12
{1,4} Not feasible
(12>10)
{2,3} 3+4=7 $12+$40=$52
{2,4} 3+5=8 $12+$25=$37
$40+$25=$65
{3,4} 4+5=9
(Feasible)
7+3+4=14
{1,2,3} Not feasible
(14>10)`
7+3+5=15
(15>10)
7+4+5=16
(16>10)
3+4+5=12
(12>10)
7+3+4+5=19
{1,2,3,4} Not feasible
(19>10)
Since the subset {3, 4} gives the maximum value $65, it is the feasible solution, so
item 3 and item 4 can be put in the Knapsack bag.
Because in this method, each element of the problem‘s domain has to be searched
for obtaining solution. Hence these problems are also called as NP-hard problems
3. Assignment Problem
Consider that there are n people who need to be assigned to execute n jobs i.e only
one person is assigned to execute one job at a time. Then problem is to find such
assignment that gives smallest total cost. The cost can be computed as cost C[i, j, k, l]
C[i, j, k, l] = Job i is assigned to Person 1, Job j is assigned to Person 2, Job k is
assigned to Person 3, Job 4 is assigned to Person 4.

Example 1
Person Job 1 Job 2 Job 3 Job 4
Person 1 9 2 7 8
Person 2 6 4 3 7
Person 3 5 8 1 8
Person 4 7 6 9 4
<1, 2, 3, 4> Cost = 9 + 4 + 1 + 4 = 18

<1, 2, 4, 3> Cost = 9 + 4 + 8 + 9 = 30
<1, 3, 2, 4> Cost = 9 + 3 + 8 + 4 = 24
<1, 3, 4, 2> Cost = 9 + 3 + 8 + 6 = 26
<1, 4, 2, 3> Cost = 9 + 7 + 8 + 9 = 33
<1, 4, 3, 2> Cost = 9 + 7 + 1 + 6 = 23
The no. of permutation for assignment problem is n!.
Example 2
Person Job 1 Job 2 Job 3 Job 4

Person 1 10 3 8 9
Person 2 7 5 4 8
Person 3 6 9 2 9
Person 4 8 7 10 5
The cost can be obtained by assigning the jobs in various combinations as

< 1, 2, 3, 4 > Cost = 10 + 5 + 2 + 5 = 22
< 1, 2, 4, 3 > Cost = 10 + 5 + 9 + 10 = 34
< 1, 3, 4, 2 > Cost = 10 + 4 + 9 + 7 = 30
< 1, 3, 2, 4 > Cost = 10 + 4 + 9 + 5 = 28
< 1, 2, 4, 3 > Cost = 10 + 5 + 9 + 10 = 34
< 1, 4, 2, 3 > Cost = 10 + 8 + 9 + 10 = 37
< 1, 4, 3, 2 > Cost = 10 + 8 + 2 + 7 = 27
Thus by trying 24 permutations (n! = 4! = 24), we can obtain feasible solution.

The feasible solution < 2, 1, 3, 4 > i.e . Cost = 3 + 7 + 2 + 5 = 17

Thus we have to generate n! instances to find solution using exhaustive search method
is for solving such problems.
4. Apply Divide and Conquer techniques for sorting techniques. [ CO2 – L3 -

Nov/Dec 2009]
Divide & conquer technique is a top-down approach to solve a problem.The algorithm
which follows divide and conquer technique involves 3 steps:Divide the original problem
into a set of sub problems.Conquer (or Solve) every sub-problem individually, recursive.
Combine the solutions of these sub problems to get the solution of original problem.
Divide and Conquer is one of the best algorithm design technique
Algorithm DC(p)
{
If P is too small then
Return solution of P.
Else
{
Divide (p) and obtain p1, p2, …..pn where n ≥ 1
Apply DC to each sub problem
Return combine (DC(p 1),
DC( p2)….Dc(pn));
}
}
divides the problem into two smaller sub problems.

Example:To compute sum of n numbers then by divide and conquer

we can solve the problem as
(a0 + ….an-1)
(a0 + ….a[n/2]-1) (a[n/2] + ….an-1)

Solution 1 Solution 2
(a0 + ….an-1)
If we want to divide a problem of size n in to a size of n /b taking f(n) time to divide
and combine , then we can set up recurrence relation for obtaining time for size n
is T (n) = a T (n/b) + f (n),
T(n/b) = Time for size n/b time required for dividing the
problem in to sub problem.
T(n) = Time for size n
n = number of sub instances
The above equation is called general divide and conquer recurrence. The order of
growth of T(n) depends upon the constants a, b and order of growth function f(n).
Divide and Conquer technique
Examples for divide and conquer method are,
 Binary search
 Quick sort
 Merge sort

Example 1 :
Consider the problem of computing the sum of number a 0 …… an-1.If n > 1, the
problem is divided into two instances of the same problem.They areTo compute the
sum of the first [n/2] numbers.To compute the sum of the remaining [n/2] numbers.Once
the two instances are computed, add their values to get the sum of original problem.
a0 + a1 +……+ an-1 = (a0 + a1 +……+ a[n/2]-1) + (a[n/2] +……+ an-1)
An instance of size n can be divided into several instances of size
n/b, Where a and b are constants
a ≥ 1 and b > 1
The recurrence for the running time T(n) is
T(n) = aT(n/b) + f(n) ,
which is called as general divide and conquer recurrence where,
f(n) is a function that accounts for the time spent on dividing the problem into smaller
ones and on combining their solutions.
The order of growth of T(n) depends on the values of the constants ‗a‘ and ‗b‘ and the
order of growth of the function f(n).
For example, the recurrence equation for the number of additions is
a(n) = 2a(n/2) + 1
Advantages of divide and conquer

The time spent on executing the problem using divide and conquer is smaller than other
methods.
The divide and conquer approach provides an efficient algorithm in computer science.
The divide and conquer technique is ideally suited for parallel computation in which
each sum problem can be solved simultaneously by its own processor.
5. Explain the Merge Sort algorithm with the help of illustrative. [ CO2 – L2 -
Dec 2011/2012/2013]
Example.
The merge sort is a sorting algorithm that uses the divide and conquer strategy.
Division is dynamically carried out.
Merging is the process of combining two or more files into a new sorted file.
Merge sort on an input array with n elements consists of three steps:
Divide: partition array into two sub lists s1 and s2 with n/2 elements each
Conquer: then sort sub list s1 and sub list s2.
Combine: merge s1 and s2 into a unique sorted group.
Merge sort is a perfect example of a successful application of the divide and conquer
technique.
It sorts a given array A[0…..n − 1] by dividing it into two halves A[0…..[n/2]−1] and

A[[n/2]…..n − 1].
It sorts each half separately by using recursive procedure, and Then, merging the two
smaller sorted arrays into a single sorted one.Steps to be followed
The first step of the merge sort is to chop the list into two If the list has even length, split
the list into two equal sub lists.If the list has odd length, divide the list in two by making
the first sub list one entry greater than the second sub list.Then split both the sub lists
into two and go on until each of the sub lists are of size one.Finally, start merging the
individual sub lists to obtain a sorted list.
Example:
The operation of the algorithm for the array of element (8,3,2,9,7,1,5,4) is explained in
the figure given below
8 3 2 9 7 1 5
4
8 3 2 7 1 5
9 4
8 2 9 7 1 5 4
3
8 3 2 9 7 1 5 4
3 8 2 9 1 7 4 5
2 3 8 1 4 5
9 7
1 2 3 4 5 7 8
9
ALGORITHM
Algorithm Mergesort(A[0..n − 1])

//Sorts array A[0..n − 1] by recursive mergesort

//Input: An array A[0..n − 1] of orderable elements
//Output: Array A[0..n − 1] sorted in nondecreasing 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]
Merge sort(B[0..[n/2] − 1])
Mergesort(C[0..[n/2] − 1])
Merge (B, C, A) //see below
The merging of two sorted arrays can be performed as follows.
Two pointers are initialized to point to the first elements of the arrays being merged.
Then the elements are compared and the smaller of both is added to a new array or list
being constructed.
Then the index of that smaller element is incremented to point to its immediate
successor in the array.
The above steps are continued until one of the two given array is exhausted.
Then the remaining elements of the other array are copied to the end of the next array.
Algorithm Descriptive and Implementation

ALGORITHM Merge(B[0..p − 1], C[0..q − 1], A[0..p + q − 1])
//Merges two sorted arrays into one sorted array
//Input: Arrays B[0..p − 1] and C[0..q − 1] both sorted
//Output: Sorted array A[0..p + q − 1] of the elements of B //and 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]
Efficiency of Merge Sort

In merge sort algorithm the two recursive calls are made. Each recursive call focuses on

n/2 elements of the list .

After two recursive calls one call is made to combine two sublist i.e to merge all n
elements.
Hence we can write recurrence relation as T(n) = T(n/2) + T(n/2) + cn
T(n/2) = Time taken by left sublist
T(n/2) = time taken by right sublist
T(n) = time taken for combining two sublists
where n> 1 T (1) = 0
The time complexity of merge sort can be calculated using two methods
Master theorem
Substitution method
Master theorem
Let , the recurrence relation for merge sort is
T(n) = T(n/2) + T(n/2) + cn
let
T(n) = aT(n/b) + f(n) be a recurrence relation
i.e. T(n) = 2T(n/2) + cn ------- ( 1 )
T(1) = 0 ----------- (2 )
As per master theorem
T(n) = Θ (n d long n ) if a = b
As equation ( 1),
a =2 , b = 2 and f(n) = cn and a = bd
i.e 2 = 2`
This case gives us ,
T (n) =Θ (n log2 n)
Substitution method
Let, the recurrence relation for merge sort be
T(n) = T(n/2) + T(n/2) + cn for n>1
i.e. T(n) = 2T(n/2) + cn for n>1 ------- (3)
T(1) = 0 -------(4)
Let us apply substitution on equation ( 3) .
Assume n=2k
T(n) = 2T(n/2) + cn
T(n) = 2T(2k/2 ) + c.2k
T(2k) = 2T(2k-1) + c.2k

If k = k-1 then,
T(2k) = 2T(2k-1) + c.2k
T(2k) = 2[2T(2k-2) + c.2k -1] + c.2k
T(2k) = 22 T(2k-2) + 2.c.2k -1 + c .2k
T(2k) = 22 T(2k-2) + 2.c.2k /2 + c.2k
T(2k) = 22 T(2k-2) + c.2k + c.2k
T(2k) = 22 T(2k-2) + 2c .2k
Similarly we can write,
T(2k) = 23 T(2k-3) + 3c .2k
T(2k) = 24 T(2k-4) + 4c .2k
…..….
T(2k) = 2k T(2k-k) + k.c.2k
T(2k) = 2k T(20) + k.c.2k
T(2k) = 2k T(1) + k.c.2k -------- (5)
But as per equation (4), T(1) =0
There equation (5) becomes ,
T(2k) = 2k .0 +. k. c . 2k
T(2k) = k. c . 2k
But we assumed n=2k , taking logarithm on both sides.
i.e. log 2 n = k
Therefore T(n) = log 2 n. cn
Therefore T (n) =Θ (n log2 n)
Time complexity of merge sort
Θ (n log2 n) Θ (n log2 n) Θ (n log2 n)
Application of Merge Sort

1.Sorting
2.Tape Sorting
3.Data Processing
Demerit
The algorithm requires linear amount of extra storage.
6. Explain the Quick Sort algorithm with the help of illustrative example.[ CO2 –
L2 - Nov/Dec 2012]
Quick sort is a sorting algorithm that uses the divide and conquers strategy.

The three steps of quick sort are as follows:
Divide:
Split the array into two sub arrays that each element in the left sub array is less than or
equal the middle element and each element in the right sub array is greater than the
middle element .
The splitting of the array into two sub array is based on pivot element.
All the elements that are less than pivot should be in left sub array and all the elements
that are more than pivot should be in right sub array
Conquer: Recursively sort the two sub arrays.
Combine:
Combine all the sorted elements in a group to form a list of sorted elements
Quick sort is also referred as Partition Exchange sort. The problem of sorting a set is
reduced to the problem of sorting two smaller subsets.Quick sort divides input elements
according to their position in the array.It also divides the input elements according to the
value of element.To achieve the partition, quick sort rearrange the given array element
a[0,..n-1].It is a situation where all the elements before the position ‗S‘ are smaller than
or equal to a[s] and all the elements after position ‗s‘ are greater than or equal to a[s].
The partition is shown as
a[0]….a[s-1] a[s] a[s+1]……a[n-1]
all are ≤a[s] all are ≥a[s]

These elements are mid These elements are
Less than A[m] Greater than A[m]
After partitioning, a[s] will be in its final position in the sorted array.
Then sorting of element of two sum arrays preceding and following a[s] can be done
independently.
After both scans stop, three situations may arise, depending on whether or not the
scanning indices have crossed.
1. If scanning indices i and j have not crossed, i.e., i < j, we simply

exchange A[i] and A[j ] and resume the scans by incrementing i
and decrementing j, respectively:
i P All elements ≤P ≥P ……. ≤P All elements ≥P

P- pivot element
2. If the scanning indices have crossed over, i.e., i > j, we will have
partitioned the Sub array after exchanging the pivot with A[j].
j i
P All elements ≤P ≥P ≤ P All elements ≥P
3. Finally, if the scanning indices stop while pointing to the same element, i.e.,
i = j, the value they are pointing to must be equal to p.
Thus, we have the sub array partitioned, with the split position s = i = j :
i=j
P All elements ≤P =P All elements ≥P
Combine the last case with the case of crossed-over indices (i > j ) by exchanging the
pivot with A[j] whenever i ≥ j .
Example
The array elements are
5 3 1 9 8 2 4 7
The first element of array is chosen as pivot element.
Two indices i and j are used for scanning.
P i j
5 3 1 9 8 2 4 7
P i j
5 3 1 9 8 2 4 7
P i j
5 3 1 9 8 2 4 7
Now exchange the elements 9 and 4 now array becomes,
P i j
5 3 1 4 8 2 9 7
Now also exchange a[i] and a[j], the resultant array becomes,
P i j
5 3 1 4 2 8 9 7
Now the scanning indices i and j have not crossed (ie) i < j, simply exchange i and j.
The array becomes
P j i
5 3 1 4 2 8 9 7
Since a[j] < pivot, (2<5) exchange them.
The result is
P
2 3 1 4 5 8 9 7

Now, the array has been sub divided into sub array with pivot element as middle.
Sub array 1
2 3 1 4
P i j
2 3 1 4
P i j
2 3 1 4
Exchange a[i] and [j]
P i j
2 1 3 4
Since i < j, exchange a and j
P j i
2 1 3 4
Since a[j] < pivot, (1 < 2) exchange i and j
P i j
1 2 3 4
Sub array 3
3 4
P ij
3 4
Here i=j, ie both points to the same element.
j j
3 4
Sub array 2
8 9 7
P i j
8 9 7
Exchange a[i] and a[j]
The sub array 2 becomes
P i j
8 7 9
Here i < j simply exchange i and j
It becomes
P j i
8 7 9
Since a[j] < pivot, exchange them
7 8 9
Hence, the array elements are sorted. The sorted array is
1 2 3 4 5 7 8 9

Recursive Calls Tree
Tree of recursive calls to Quicksort with input values l and r of subarray bounds and split
position s of a partition obtained.
ALGORITHM FOR QUICK SORT

ALGORITHM Quicksort(A[l..r])
//Sorts a subarray by quicksort
//Input: Subarray of array A[0..n − 1], defined by its left and
//right indices l and r
//Output: Subarray A[l..r] sorted in nondecreasing order
if l<r
s ←Partition(A[l..r]) //s is a split position
Quicksort(A[l..s − 1])
Quicksort(A[s + 1..r])
ALGORITHM Hoare Partition(A[l..r])

//Partitions a subarray by Hoare‘s algorithm, using the first //element as a pivot
//Input: Subarray of array A[0..n − 1], defined by its left and //right indices l and r (l < r)
//Output: 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
repeat j ← j − 1 until A[j ] ≤ p
swap(A[i], A[j ])
until i ≥ j
swap(A[i], A[j ]) //undo last swap when i ≥ j
swap(A[l], A[j ])
return j
Efficiency of Quick Sort

The number of key comparisons made before a partition is achieved is n + 1 if the
scanning indices i and j cross over.
The number of key comparisons is n, if the scanning indices i and j coincides.
Best Case Analysis( split in the middle)

If the array is always partitioned at the mid , then it brings the best case efficiency of an
algorithm
The number of key comparisons in the best case satisfies the recurrence
Cbest(n) = 2 Cbest(n/2) + n for n > 1,
Or
C(n) = C (n/2) + C (n/2) + n ----------( 1 )
Time required to Time required to Time required for

sort left sub array sort right sub array partitioning the sub array
and Cbest(1) = 0.
Using Master Theorem

Solve equation (1) using Master Theorem
If f(n) ∈ Θ (n d ) then
T(n) = Θ (n d) if a < bd
T(n) = Θ (n log n ) if a = bd
d
T(n) = Θ (n log b a ) if a> b bd

C(n) = 2 C(n/2) +n
Here f(n) ∈ n1 therefore d = 1
Now , a = 2 and b = 2
As from case 2 we get a = bd i.e. 2 = 21
We get ,
T(n) i.e C(n) = Θ (nd log n )
Cbest(n) = Θ (n log n)

Best case time complexity of quick sort is Θ (n log n)

Using substitution method
C(n) = C (n/2) + C (n/2) + n ----------( 1 )
C(n) = 2C (n/2) +n
Assume n = 2K since each time the list is divide into two equal halves . then
equation becomes,
C(2K) = 2C(2k /2) + 2k
C(2K) = 2C(2k -1) + 2k
Now substitute C(2k -1 ) = 2C(2k-2) + 2k-1
C(2K) = 2[2C(2k-2) + 2k-1] + 2k
C(2K) = 22C(2k-2) + 2.2k-1 + 2k
C(2K) = 22C( 2k-2) + 2k + 2k
C(2K) = 22C( 2k-2) +2.2k
If we substitute C(2k -2) then ,
C(2K) = 22C( 2k -2) +2. 2k
C(2K) = 22[2 C(2k -3) + 2k – 2] + 2.2k
C(2K) = 23C(2k -3) +22. 2k – 2 + 2.2k
C(2K) = 23C(2k -3) + 2k + 2.2k
C(2K) = 23C(2k -3) + 3.2k
Similarly we can write
C(2K) = 24C(2k -4) + 4.2 k
----
K k k-k k
C(2 ) = 2 C(2 ) + k.2
C(2K) = 2kC( 20) + k.2 k
C(2K) = 2kC( 1) + k.2 k
C(1) = 0
hence the above equation becomes
C (2K) = 2k.0 + k.2 k
now as we assumed n = 2k we can also say
n = log 2 n [by taking logarithm on both side]
C( n) = n.0 + log 2 n . n
Thus it is proved that best case time complexity of quick sort
is Θ (n log n)
Worst Case Analysis (sorted array)

The worst case for quick sort occurs when the pivot is a minimum or maximum of all the
elements in the list .
For example,
if A[0..n − 1] is a strictly increasing array and we use A[0] as the pivot,

The left-to-right scan will stop on A[1]

The right-to-left scan continues upto A[0]
The total number of key comparisons made will be equal to
Cworst(n) = (n -1) + n
Cworst(n) = (n - 1) +( n-2) + ... + 2 + 1
1 + 2+ 3 +---- + n = n (n + 1)/2 = ½ n2
Cworst(n) ∈ θ(n2)
The time complexity of worst case of quick sort is θ (n2)
Average Case Analysis (random array)

Let Cavg(n) be the average number of key comparison made by Quick Sort.
The partition split can be happen in each position S (0≤S≤n-1) with the probability 1/n.
The recurrence relation is
Cavg (n) ≈ 2n ln n ≈ 1.39 n log2 n.

Thus, on the average case, Quick Sort makes 38% more comparison the best case.
Hence average case time complexity of quick sort is Θ ( n log n)
Time complexity of quick sort

Θ(n log n) Θ(n log n) θ (n2)
Application
Internal sorting of large data sets.
To improve the efficiency of the Quick sort various methods are used to choose the
pivot element.
One such method is called, median of three partitioning that uses the pivot element as
the median of left most, right most and the middle element of the array.
7. Write an algorithm to perform binary search on a sorted list of elements.

Analyse the algorithm for the best case , worst case and average case. [ CO2 - L1
– Apr/May 2011,Dec 2008]

The binary search algorithm is one of the most efficient searching techniques which
require the list to be sorted in ascending order.
To search for an element in the list, the binary search algorithms split the list and locate
the middle element of the list.
The middle of the list is calculated as middle := (l + r) div n-numberof element in
list
The algorithm works by comparing a search key element ‗k‘ with the array middle
element a[m] After comparison, any one of the following three conditions occurs.
If the search key element ‗k‘ is greater than a[m], then the search element is only in the
upper or second half and eliminate the element present in the lower half. Now the
value of l is middle m+1.
If the search key element ‗k‘ is less than a[m], then the search element is only in the
lower or first half. No need to check in the upper half. Now the value of r is middle
m-1.If the search key element ‗k‘ is equal to a[m] , then the search key element k is
found in the position m, Hence search operation is complete.
The above steps are repeated until the search element is found, which is equal to
the middle element or the list consists of only one element that is not equal to the
search key element.
a[0]….a[m-1] a[m] a[m+1]……a[n-1]
search have if k<a[m] k search have if k>a[m]
Example:
The list of element are 3,14,27,31,39,42,55,70,81,85,93,98 and searching for k=70
in the list.
0 1 2 3 4 5 6 7 8 9 10 11 12
3 14 27 31 39 42 55 70 74 81 85 93 98
m- middle element
m = n div 2
= 13 div 2
m=6
0 1 2 3 4 5 6 7 8 9 10 11 12
3 14 27 31 39 42 55 70 74 81 85 93 98
m
0 1 2 3 4 5 6 7 8 9 10 11 12
3 14 27 31 39 42 55 70 74 81 85 93 98
l m
Since k> a[m] , then , l=7.

So, the search element is present in second half.
Now the array becomes

7 8 9 10 11 12
70 74 81 85 93 98
l r
m = (l + r) div 2
= 19 div 2
m=9
7 8 9 10 11 12
70 74 81 85 93 98
l m r
Since k< a[m] and 70 < 81
So, the element is present in the first half
Now, the array becomes

7 8
70 74
l r
m = (l + r) div 2
= (7+8) div 2
m=7
7 8
70 74
l, m r
Now k = a[m] and 70 =70
Hence, the search key element 70 is found in the position 7 and the search
operation is completed.
Algorithm Description and Implementation

Establish the array a[0….n-1] and the value to be found k.
Assign the l and r variables to the array limits.
While l<r do
Compute the middle position of the remaining array segment to be searched.
If the value found is greater than current middle then
Adjust l value according
else
Adjust r value according

If the array element at ‗l‘ position is equal to the value to be found then
Return found and position
else
Return not found and -1.
Algorithm
Algorithm BinSearch (var a, n elements, n, x: integer)
Var l,r,m:integer;
//Input: Given an array a[0….n-1] sorted in ascending order //and search key k.
//Output: An index of the array‘s element that is equal to k or //-1 if there is no such
element.
begin
l:=0; r := n-1;
while (l≤ r) do
begin
mid := [(l + r) div 2];
if k = a[mid] then
return m;
else if k <a[m] then
r:=m-1;
else
l:=m+1;
end:
return -1
end
Efficiency of Binary Search

The standard way to analyze the efficiency is to count number of times search key
is compared with an element of the array.
Worst Case Analysis

The worst case includes all arrays that do not contain a search key.
The recurrence relation for Cworst(n) = Cworst (n/2) + 1, for n > 1 ----- (1)
Time required to one comparison

compare left sublist made with middle element
or right sub list
Cworst(1) = 1 -------- ( 2 )

The above recurrence relation can be solved further . assume n=2k the equation ( 1 )
becomes
Cworst(2k) = Cworst(2 k /2)+ 1
Cworst(2k) = Cworst(2 k-1)+ 1 ------ ( 3 )
Using backward substation method , we can substitute
Cworst(2k-1) = Cworst(2k-2)+ 1
Then equation (3) becomes
Cworst(2k) = [Cworst( 2 k-2)+ 1] + 1
Cworst(2k) = Cworst( 2 k-2)+ 2
Then
Cworst(2k) = [Cworst( 2 k-3)+1]+ 2
Cworst(2k) =Cworst( 2 k-3)+3
---
---
Cworst(2k) =Cworst( 2 k-k)+k
Cworst(2k) =Cworst( 2 0)+k
Cworst(2k) =Cworst( 1 )+k ----- (4)
But as per equation (2 )
as we have assumed n = 2k taking logarithm (base 2 )on both sides
log 2 n = log 2 2k
log 2 n = k. log 2 2
log 2 n = k(1) therefore log 2 2 =1 therefore k = log 2 n
Cworst(1) = 1 the we get equation ( 4 )
Cworst(2k) = 1 + k
Cworst(n) = 1 + log2n ----- (2
Cworst(n) = log2n for n>1
The worst case time complexity of binary search is Θ(log2n)
As Cworst(n) = log2n + 1
we can verify equation ( 1) with this value.
Cworst(n) = Cworst[(n/2)] + 1
In equation (1) put n = 2i
L.H.S
Cworst(n) = log2n + 1
= log2(2i )+ 1
= log 2 2 + log 2i + 1
= 1+ log 2i + 1

= 2 + log 2i
Cworst(n) =2 + log 2i
R.H.S
Cworst(n/2)+1 = log 2(2i/2 )+ 1
= log 2i + 1
= log 2 2i + 1+ 1
= 2 + log 2i
Cworst(n/2) =2 + log 2i
L.H.S = R.H.S
Hence
Cworst(n) = log 2n + 1 and
Cworst(i) = log 2i + 1 are same
Hence
Cworst(n) = Ө(log n )
Average Case Analysis

To obtain average case efficiency of binary search we will consider some sample
input n. if n = 1
i.e. only element 11 is there only one search is required to search some KEY.
If n = 2 and search key = 22
11 22
0 1
Two comparisons are made to search 22
Similarly n= 4, 8, 16 and search key = 44, 88
11 22 33 44
0 1 2 3
N Total comparison ( c)
1 1
2 2
4 3
8 4
5
16
Observing the above given table we can write

log2 n + 1 = c
for instance

if n= 2 then
log2 2 = 1
then c= log 2 2 + 1
c=1+1
c =2
if n = 8 , then
c = log2 n + 1
= log2 8 + 1
=3+1
C=4
Average number of comparison made by the binary search is slightly smaller than
worst case.
Cavg(n) log2 n
The average number of comparison in the successful search is Θ(log 2n)
Advantages
In this method elements are eliminated by half each time. So it is very faster than
the sequential search.
It requires less number of comparisons than sequential search to locate the search
key element.
Disadvantages
An insertion and deletion of a record requires many records in the existing table be
physically moved in order to maintain the records in sequential order.
The ratio between insertion/deletion and search time is very high.
Applications of binary search

The binary search is an efficient searching method and is used to search desired record
from databaseFor solving nonlinear equations with one unknown this method is used.
Time complexity of binary search

Θ(1) Θ(log2n) Θ(log2n)
Difference between sequential and binary search :

Sequential technique binary search technique

This is the simple technique of searching an This is the efficient technique of searching
element an element
This technique does not require the list to be This technique require the list to be sorted.
sorted Then only this method is applicable
The worst case time complexity of this The worst case time complexity of this
technique is O(n) technique is O(log n)
Every element of the list may get compared Only the mid element of the list is compared
with the key element. with key element.
8. Explain the method of multiplication of large numbers with the help of

illustrate example Multiplication of Large Integer. [ CO2 – L3 - May 2014]
In this method of multiplying two numbers multiplies the multiplicand by each digit of
multiplier and then adds up all the properly shifted results. This method is also called grade –
school multiplication
For example: 42×34=168
But this method is not convenient for performing multiplication of large integers . hence
let us discuss an interesting algorithm of multiplying large integer .
For example
To demonstrate the basic idea of the algorithm, let us start with a case of two-digit integers,
say, 23 and 14.
These numbers can be represented as follows:
2. 101 + 3 .100 and 14 = 1 . 101 + 4 . 100
Now let us multiply both the numbers
23 ∗ 14 = (2 . 101 + 3 . 100) * (1 . 101 + 4 . 100 )
= (2 ∗ 1) 102 + (2 ∗ 4 + 3 ∗ 1) 101 + (3 ∗ 4) 100
=2*100+ (8 +3)10 +(12) 1
=200+110+12
= 322
Let us formulate this method Let
c=a∗b

c = c2102 + c1101 + c0 ------(1)

Where,
c2 = a1 ∗ b1 -->is the product of their first digits,
c0= a0 ∗ b0 -->is the product of their second digits,
c1 = (a1 + a0) ∗ (b1 + b0) − (c2 + c0) --> is the product of the sum of the a‘s digits and the sum
of the b‘s digits minus the sum of c2 and c0
The 2 digit numbers are
a = a1 a0
b = b1 b0
Let perform multiplication operation with the help of formula given in equation (1)
c=a∗b
c= 23 * 14
Where a1 = 2, a0 = 3 , b1 = 1, b0 = 4
Let us obtain c0, c1, c2 values
c2 = a1 ∗ b1
=2*1
c2 = 2
c0= a0 ∗ b0
=3*4
c0 = 12
c1 = (a1 + a0) ∗ (b1 + b0) − (c2 + c0)
= (2 + 3) *( 1 + 4) – (2 +12)
= 5 * 5 – 14
c1 =25-14
c1 = 11
Therefore
a * b = c2 102 + c1 101 + c0
= 2 * 100 +11 * 10 +12
= 200 +110 +12
a * b = 322
We can generalize this formula as
c=a∗b
c = c2102 + c1101 + c0
where , n is total number of digits in the integer
c2 = a1 ∗ b1
c0= a0 ∗ b0
c1 = (a1 + a0) ∗ (b1 + b0) − (c2 + c0)

Analysis
In this method there are 3 multiplication operations 1 digit numbers
i.e c2 = a1 ∗ b1 --> multiplication 1
c0 = a0 ∗ b0 --> multiplication 2
c1 = (a1 + a0) ∗ (b1 + b0) − (c2 + c0)->multiplication 3
The multiplication of n digit numbers requires three multiplications of n/2 digit
numbers, the recurrence equation for the number of multiplication M(n) will be,
M(n)=3M(n/2), for n>1
And M(1)=1 where n = 1
Now put n=2k Solving it by backward substitutions for
M(2k)=3 M(2k /2)
M(2k)=3 M(2k-1)
=3[3 M(2k-2)]
=32 M(2k-3)
=3k M(2k-k)
=3k M(20) Since 20 = 1
k
=3
Using equation (3) , M(n) = 1
Therefore M(2k) = 3k ------ (4)
as n= 2k we get k = log2n ,equation (4)
M(n)= 3 log 2n
=n log 2 3 therefore a log b c = c log2 a
≈ n 1.585
M(n) ≈ n1.585
9. Write an algorithm for performing matrix multiplication using Strassen‟s Matrix

Multiplication[ CO2 – L1 - May 2014]
The Strassen‘s matrix multiplication algorithm finds the product C of two 2 by 2 matrices A
and B with just seven multiplication as opposed to eight required by the brute force
algorithm. It is accomplished by using the following formula.
C=A×B
The multiplication gives

C00 = a00 ×b00 +a01 ×b10

C01 = a00 ×b01 +a01 ×b11

C10 = a10 ×b01 +a11 ×b10
C11 = a10 ×b00 +a01 ×b11
Thus to accomplish 2 ×2 matrix multiplication there are total 8 multiplication and 4
additions
Divide: divide matrices into sub – matrices : A0 , A1, A2 etc
Conquer: use a group of matrix multiply equations
Combine: recursively multiply sub – matrices and get the final result of multiplication
after performing required additions or subtractions.
Where
m1 = (a00 + a11) * (b00 + b11)
m2 = (a10 + a11) * b00
m3 = a00 * (b01 - b11)
m4 = a11 * (b10 - b00)
m5 = (a00 + a01) * b11
m6 = (a10 + a00) * (b00 + b01)
m7 = (a01 + a11) * (b10 + b11)
Thus, to multiply two 2 by 2 matrices, strassen‘s algorithm makes seven multiplication

and 18 additions/subtractions where as the brute force algorithm requires eight
multiplication and for additions.These numbers should not lead us to multiplying 2 by 2
matrices by strassen‘s algorithm.its importance stems from its asymptotic
superiority as matrix order n goes to infinity.Let A and B be two n-by-n matrices where n
is a power of two.If n is not a power of two, matrices can be added with rows and
column of zeros.
The matrix A,B and their product is divided into 4,n/2 by n/2 submatrices each as
follows
The value C00 can be computed as either a00 * b00 or a01 * b10 or as M1 + M4 – M5 +
M7 , where M1 , M4 , M5 and M7 are found by strassen‘s formula with the numbers
replaced by the corresponding submatrices. The seven products of n/2 and n/2 matrices
are computed recursively by the strassen‘s matrix multiplication algorithm.

Efficiency of strassen‟s matrix multiplication

If M(n) is the number of multiplication made by strassen‘s algorithm in multiplying two n
by n matrices where n is a power of 2, then the recurrence relation is
M(1) = 1
M(n)=7 M(n/2)
Since n=2k yields
M(2k)=7k M(n/2k)
=7[7 M(2k-2)]
=72 M(2k-2)
=7i M(2k-i)
=7k M(2k-k)
=7k
Since k=log2n
M(n)= 7 log2n
=n log27
≈ n2.807
Which is smaller than n3 required by the brute force algorithm.
Numbers of multiplications are reduced by making extra additions.
To multiply two matrices of order n>1 , the algorithm needs to multiply seven matrices of
order n/2 and make 18 additions of matrices of size n/2.
When n = 1 , no additions are made since two numbers are simply multiplied.
The number of additions A(n) made by the Strassen‘s algorithm given by recurrence
A(n) = 7A(n/2) + 18(n/2) , for n > 1
A(1) = 0
According to the Master Theorem.
A(n) ∈ ϴ( n log2n)
In other words, the number of additions has the same order of growth as the number of
multiplications.
As a result, Strassen‘s algorithm in ϴ( n log2n), which is a better efficiency class than
ϴ(n2) or the brute force method.
10. Write an algorithm for performing The Closest-Pair and Convex-Hull

Problems by Divide-and-Conquer. [ CO2 - L1 –Dec 2007/2010/2012/2013]
There exits a set of points on a plane which is said to be convex if for any two points
A and B in the set , the entire line segment with the end points at A and B belongs to
the set
Example

Is a convex hull Is not a convex hull
The convex – hull problem of finding the smallest convex polygon that contains given
n points in a plane can be solved using divide and conquer method.
This version of solving convex hull problem is called quick hull because this method is
based on quick sort technique.
Algorithm
Step 1 : Sort the points ( p1 ,p2 ,p3,…pn) by their x – coordinates
Step 2 : Repeatedly find the convex hull through p1 to p n/2
Step 3 : Repeatedly find the convex hull through p n/2+1 to p n
Step 4 : Merge the two convex hulls
The Closest-Pair Problem

Let P be a set of n > 1 points in the Cartesian plane.
For the sake of simplicity, we assume that the points are distinct.
If 2 ≤ n ≤ 3, the problem can be solved by the obvious brute-force algorithm.
If n > 3, we can divide the points into two subsets Pl and Pr of n/2 and n/2 points,
respectively, by drawing a vertical line through the median m of their x coordinates
so that n/2 points lie to the left of or on the line itself, and n/2 points lie to the right
of or on the line.
Then we can solve the closest-pair problem recursively for subsets Pl and Pr .
Let dl and dr be the smallest distances between pairs of points in Pl and Pr,
respectively, and let d = min{ dl , dr }.
Note that d is not necessarily the smallest distance between all the point pairs because

points of a closer pair can lie on the opposite sides of the separating line.
Let S be the list of points inside the strip of width 2d around the separating line,
obtained from Q and hence ordered in non decreasing order of their y coordinate.
We will scan this list, updating the information about dmin, the minimum distance seen
so far, if we encounter a closer pair of points.
Initially, dmin = d, and subsequently dmin ≤ d. Let p(x, y) be a point on this list.
For a point p(x, y) to have a chance to be closer to p than dmin, the point must follow
p on list S and the difference between their y coordinates must be less than dmin.
ALGORITHM EfficientClosestPair(P, Q)
//Solves the closest-pair problem by divide-and-conquer
//Input: An array P of n ≥ 2 points in the Cartesian plane //sorted in non decreasing
order of their x coordinates and an //array Q of the same points sorted in non
decreasing order of //the y coordinates
//Output: Euclidean distance between the closest pair of //points
if n ≤ 3
return the minimal distance found by the brute-force algorithm
else
copy the first _n/2_ points of P to array Pl
copy the same _n/2_ points from Q to array Ql
copy the remaining _n/2_ points of P to array Pr
copy the same _n/2_ points from Q to array Qr

dl←EfficientClosestPair(Pl, Ql)
dr←EfficientClosestPair(Pr, Qr)
d ←min{dl, dr}
m←P[_n/2_ − 1].x
copy all the points of Q for which |x − m| < d into array S[0..num − 1]
dminsq ←d2
for i ←0 to num − 2 do
k←i + 1
while k ≤ num − 1 and (S[k].y − S[i].y)2 < dminsq
dminsq ←min((S[k].x − S[i].x)2+ (S[k].y − S[i].y)2, dminsq)
k←k + 1
return sqrt(dminsq)
The algorithm spends linear time both for dividing the problem into two problems half
the size and combining the obtained solutions. Therefore, assuming as usual that n
is a power of 2, we have the following recurrence for the running time of the
algorithm:T (n) = 2T (n/2) + f (n),where f (n) ∈ Ө(n). Applying the Master Theorem
(with a = 2, b = 2, and d = 1), we get T (n) ∈ Ө(n log n). The necessity to presort input
points does not change the overall efficiency class if sorting is done by a O(n log n)
algorithm such as merge sort.
Convex-Hull Problem
Let S be a set of n>1 points p1(x1, y1), . . . , pn (xn, yn) in the Cartesian plane.
We assume that the points are sorted in non decreasing order of their x coordinates,
with ties resolved by increasing order of the y coordinates of the points involved.
It is not difficult to prove the geometrically obvious fact that the leftmost point p1 and
the rightmost point pn are two distinct extreme points of the set‘s convex hull
Let p1 pn be the straight line through point‘s p1 and pn directed from p1to pn.
This line separates the points of S into two sets: S1 is the set of points to the left of this
line, and S2 is the set of points to the right of this line. We say that point q3 is to the
left of the line q1q2 directed from point q1 to point q2 if q1 q2 q3 forms a
counterclockwise cycle. Later, we cite an analytical way to check this
condition, based on checking the sign of a determinant formed by the
coordinates of the three points.
The points of S on the line p1 pn, other than p1 and pn, cannot be extreme points
of the convex hull and hence are excluded from further consideration.

Fig Upper and lower hulls of a set of points

The boundary of the convex hull of S is made up of two polygonal chains: an
―upper‖ boundary and a ―lower‖ boundary.
The ―upper‖ boundary, called the upper hull, is a sequence of line segments with
vertices at p1, some of the points in S1 (if S1 is not empty) and pn.
The ―lower‖ boundary, called the lower hull, is a sequence of line segments with
vertices at p1, some of the points in S2 (if S2 is not empty) and pn.
The fact that the convex hull of the entire set S is composed of the upper and lower
hulls, which can be constructed independently.
Construction of upper hull:

If S1 is empty, the upper hull is simply the line segment with the endpoints at p1 and
pn. If S1 is not empty, the algorithm identifies point pmax in S1, which is the farthest
from the line p1 pn .
If there is a tie, the point that maximizes the angle pmax p pn can be selected. (Note
that point pmax maximizes the area of the triangle with two vertices at p1and pn
and the third one at some other point of S1.)
Pmax
Pn
P1

Then the algorithm identifies all the points of set S1 that are to the left of the line p1
pmax; these are the points that will make up the set S1,The points of S1 to the left of
the line pmax pn will make up the set S1,It is not difficult to prove the following:
pmax is a vertex of the upper hull.The points inside p1 pmax pn cannot be vertices of
the upper hull (and hence can be eliminated from further consideration).There are no
points to the left of both lines p1 pmax and pmax pn.
Therefore, the algorithm can continue constructing the upper hulls of p1 U S1,1
Upmax and pmax U S1,2 U pn recursively and then simply concatenate them to get
the upper hull of the entire set p1 U S1 U pn.
If q1(x1, y1), q2(x2, y2), and q3(x3, y3) are three arbitrary points in the Cartesian plane,
then the area of the triangle q1q2q3 is equal to one-half of the magnitude of the
determinant
x1 y1 1
x2 y2 1 = x1 y2 + x3 y1 + x2 y3− x3 y2 − x2 y1− x1 y3
x3 y3 1
while the sign of this expression is positive if and only if the point q3 = (x3, y3) is to the
left of the line q1 q2.
Using this formula, we can check in constant time whether a point lies to the left of
the line determined by two other points as well as find the distance from the point
to the line.
Example 2:
The merge procedure requires finding a bridge between two hulls that are adjacent
to each other . concatenate left part of left hull and right part of right hull


Quick hull has the same Ө(n log n) worst-case efficiency as quick sort.
In the average case Ө(n2), however, we should expect a much better performance.
The average-case efficiency of quick hull turns out to be linear. ‗n‘ its computing time is
O(n2).

Unit - 3
Dynamic Programming And Greedy Technique
Part – A
1. Write the difference between Greedy method and Dynamic programming.[ CO3 –
L2 - May/June 2011]
Greedy Method Dynamic Programming
It is used to find optimal solution Enumerable all decision

among all feasible solution sequences and then pick the best.
Solutions to the sub problems do Choice can be made of what

not have to be known at each stage. looks best for the moment.
2. Write an algorithm to find shortest path between all pairs of nodes. [ CO3
- L1 - May/June 2011]
3. Write any two characteristics of Greedy Algorithm? [ CO3 - L1 - May/June 2015]

To solve a problem in an optimal way constructs the solution from given set of
candidates.As the algorithm proceeds, two other sets get accumulated among this one set
contains the candidates that have been already considered and chosen while the other set
contains the candidates that have been considered but rejected.

4. What is an optimal solution? [ CO3 - L1 - May/June 2010]

A feasible solution either maximizes or minimizes the given objective function is called as
optimal solution
5. What is Knapsack problem? [ CO3 - L1 – Nov/Dec 2011]

A bag or sack is given capacity C and n objects are given. Each object has weight
w i and profit p i .Fraction of object is considered as xi (i.e) 0 ≤ xi ≤1 .If fraction is 1
then entire object is put into sack. When we place this fraction into the sack we get
wixi and pixi.
6. Define weighted tree. [ CO3 - L1]

A directed binary tree for which each edge is labeled with a real number (weight) is called as
weighted tree.
7. What is the Greedy choice property? [ CO3 - L1]

The first component is greedy choice property (i.e.) a globally optimal solution can arrive
at by making a locally optimal choice.The choice made by greedy algorithm depends on
choices made so far but it cannot depend on any future choices or on solution to the sub
problem. It progresses in top down fashion.
8. What is greedy algorithms? [ CO3 - L1 - Dec 2011]

Greedy method is the most important design technique, which makes a choice that
looks best at that moment. A given ‗n‘ inputs are required us to obtain a subset that
satisfies some constraints that is the feasible solution. A greedy method suggests
that one can device an algorithm that works in stages considering one input at a
time.
9. Illustrate the general principle of greedy algorithm?[CO3 –L3–Dec 2010]

Determine the optimal substructure of the problem.Develop a recursive solution.
Prove that at any stage of recursion one of the optimal choices is greedy choice Thus it is
always safe to make greedy choice.Show that all but one of the sub problems induced by
having made the greedychoice is empty.Develop a recursive algorithm and convert into
iterative algorithm.
10. What is the limitation of Greedy algorithm?[CO3 - L1 - May/June 2010]

An optimization problem: Given a problem instance, a set of constraints and an
objective function.

– Find a feasible solution for the given instance for which the objective
function has an optimal value
– either maximum or minimum depending on the problem being solved.
A feasible solution satisfies the problem‘s constraints
The constraints specify the limitations on the required solutions.
11. State the principle of optimality. [ CO3 - L1 – Nov/Dec 2010]

The principle of optimality states that an optimal sequence of decisions has the property
that whatever the initial state and decision are, the remaining decisions must constitute an
optimal decision sequence with regard to the state resulting from the first decision.
12. What is dynamic programming? [ CO3 - L1 - Nov/Dec 2012]

Dynamic programming is typically applied to optimization problems. For a given problem we
may get any number of solutions. from all those solutions we seek for optimum solution (
minimum value or maximum value solution). And such an optimal solution becomes the
solution to the given problem.
13. Compare feasible and optimal solution. [ CO3 – H1 - May/June 2008]

Optimal solution
A feasible solution either maximizes or minimizes the given objective function is calle
as optimal solution
Feasible Solution
For solving the particular there exits n inputs and we need to obtain a subset that satisfies
some constraints .then any subset that satisfies these constrains is called feasible solution.
14. What are the Applications of Dynamic Programming?[CO3-L1- May2012]

Multistage Graph
Optimal Binary Search Tree (OBST)
0/1 Knapsack Problem
Travelling Salesman Problem.
All Pair Shortest Path Problem
15. Summarize Warshall‟s algorithm. [ CO3 – H2 – Nov/Dec 2011]

Warshall‘s algorithm is an application of dynamic programming technique which is used to find
the transitive closure of a directed graph.
16. Define Floyd‟s algorithm. [ CO3 - L1 - Nov/Dec 2011]

Floyd‘s algorithm is an application of dynamic programming, which is used to find the all pairs
shortest path problem.It is applicable to both directed and undirected weighted graph, but they

do not contain a cycle of negative length.
17.Define OBST? [ CO3 - L1 – May 2010]

Let { a1, a2,….an} be a set of identifiers such that a1<a2<a3…let p(i) be the
probability with which we can search for ai is Successful search.
Let , qi be the probability of searching an element x such that
ai<x<ai+1 where 0≤i≤ n is unsuccessful search . thus p(i) is
probability of successful search and q(i) is the probability of
unsuccessful search.
Then a tree which is build with optimum cost from
∑ is called optimal binary search tree
18. What is a Feasible solution ? [ CO3 - L1 – Dec 2013/May 2014]

For solving the particular there exits n inputs and we need to obtain a subset that satisfies
some constraints . then any subset that satisfies these constrains is called feasible solution.
19. State the applications of Huffman „s tree. [ CO3 - L1 - May/June 2014]

Application of Huffman trees:
Huffman encoding is used in file compression algorithm
Huffman‘s code is used in transmission of data in an encoded form
This encoding is used in game playing method in which decision trees need to be
formed
20. Write control abstraction for the ordering paradigm. [ CO3 - L1 - May/June 2012]
Algorithm store (n, limit)
{
j = 0;
For( i ← 1 to n ) do
{
Write (―append program‖, i);
Write (―permutation for tap ―,j);
j = ( j+1) mod limit ;
}
}
.

PART B
1. Define dynamic programming and explain the problems that can be solved
using dynamic programming. [ CO3 – L2 – Nov/Dec 2011/2013]
Introduction:
Dynamic Programming is a technique for solving problems with overlapping sub
problems. The smaller sub problems are solved only once and recording the results in a
table from which the solution to the original problem is obtained.
Problems that can be solved using dynamic programming:
Various problems those can be solved using dynamic programming are
For computing nth Fibonacci number
1. Computing binomial coefficient
2. Warshall‘s algorithm
3. Floyd‘s algorithm
4. Optimal binary search trees
Principle of optimality:
The dynamic programming makes use of principle of optimality when finding solution to
given problem.
The principle of optimality states that ― in an optimal sequence of choices or decisions ,
each subsequence must also be optimal‖.
When it is not possible to apply principle of optimality, it is almost impossible to obtain
the solution using dynamic programming approach.
Example:
While constructing optimal binary search tree we always select the value of k which is
obtained from minimum cost. Thus it follows principle of optimality
Computing a Binomial Coefficient:
Computing a Binomial Coefficient is a typical example of applying dynamic
programming in mathematics, particularly in combinatory.
Binomial Coefficient is a Coefficient of any of the term in the expansion of (a+b) n.
The binomial coefficient is denoted by C(n, k) or ( )

The binomial coefficient is the number of combinations or subsets of K elements from

an n element set(0≤ k ≥ n).
The name binomial coefficient comes from the participation of these numbers in the
binomial formula.
The binomial formula is
(a+ b) n =C(n.0)a n +---+C(n, i) a n-1 b n +----+ C(n. n)b n.
The three important properties are
C(n, k)=C(n-1,k-1)+C(n-1,k), for N>k>0
C(n,0)= 1
C(n, n)=1
Example: Compute C(4,2)
Solution:
n=4, k=2
C(4,2) = C(n-1,k-1)+C(n-1,k)
C(4,2) =C(3,1) +C(3,2) --------(1)
As there are two unknowns : C(3,1) and C(3,2) in above
equation we will compute these sub instance of C(4, 2)
Therefore n=3 , k=1
C(3,1) =C(2,0) +C(2,1)
C(n, 0) = 1 we can write
C(2, 0) = 1
C(3, 1) = 1 + C(2,1) -------(2)
Hence let us compute C (2, 1)
Therefore n=2 , k=1

C(2,1) = C(n-1,k-1)+ C(n-1,k)

C(2,1) =C(1,0) +C(1,1)
But as C (n, 0) = 1 and C(n, n) = 1 we get
C( 1,0) = 1 and C( 1,1) = 1
C( 2,1) = C( 1, 0) + C( 1,1)
= 1 +1
C(2,1) = 2 ------------------(3)
Put the equation (2) and we get
C(3,1) = 1 +2
C(3,1) = 3 -------------------(4)
Now to solve equation 1 we will first compute C(3, 2) with n = 3
and k = 2 Therefore
C(3,2) = C(n-1,k-1)+ C(n-1,k)
C( 3,2) = C( 2, 1) + C( 2,2)
But as C( n,n) = C( 2,2) = 1 , we will put values of C(2, 1) obtained in equation (3)
And C(2,2) in C(3,2) we get,
C( 3,2) = C( 2, 1) + C( 2,2)
= 2+ 1
C( 3,2) = 3 --------------------(5)
Put equation (4 ) and (5) in equation , then we get
C( 4,2) = C( 3, 1) + C( 3,2)
C( 4,2) = 3 + 3
C(4,2) = 6 is the final answer

2. How dynamic programming approach is used in binomial coefficient? [ CO3 -

L1 – May 2009]
The recurrence equation C(n,k)=C(n-1,k-1)+C(n-1,k) expresses the problem of
computing C(n,k) in terms of C(n-1,k-1) and C(n-1,k) lends itself to solve by the
dynamic programming technique.
The values of the binomial coefficient are recorded in a table of n+1 rows and K+1
columns, numbered from 0 to n and from 0 to k respectively, which is shown in figure
below
0 1 2 3 4 5 ……. k-1 K
0 1
1 1 1
2 1 2 1
3 1 3 3 1
4 1 4 6 4 1
5 1
K 1 1
n-1 1 C(n-1,k-1) C(n-1,k)
N 1 C(n,k)
To compute the value of C(n,k), the table of figure is filled by row , starting with row 0
and ending with row n. Each row i(0≤ i ≤ n) is filled left to right, starting with 1 because
C(n,0)=1.Rows 0 through k also end with 1 on the table‘s main diagonal (ie)
C(i,i)=1for 0≤ i ≤ k
The other entries of the table is computed by using the formula C(n,k)=C(n-1,k-1)+C(n-
1,k), for n>k>0 adding the contents of the cells in the preceding row and the previous
column in the preceding row and the same column.

Algorithm
Algorithm Binomial(n,k)
//Computes C(n,k) by the dynamic programming algorithm
// Input: A pair of nonnegative integers n≥k≥0.
//Output: The value of C(n,k)
for i←0 to n do
for j ←0 to min(i,k) do
if j=0 or j=k
C[i,j] ← 1
else
C[i,j] ← C[i-1,j-1]+ C[i-1,j]
return C[n,k]
Analysis:
The basic operation is addition i.e.
C[ i,j] ← C[i – 1, j-1] +C[i- 1, j]
Let A(n,k) denotes total additions made in computing C(n,k).
In the table, first K+1 rows of the table form a triangle and the remaining n-k
rows form a rectangle.
So the recurrence relation for A(n,k) is divided into the parts.
The recurrence relation is,
Therefore ∑

= ∑ ∑
= [ 1 + 2 + 3 + ….( k-1)] + k ∑
= +k∑
= +k(n-(k + 1) + 1)
= +k(n-k - 1 + 1)
As no edge from a to d ,
value is 0
= +k(n-k )
= k2/ 2 – k/2 + nk - k2 =Θ(nk)

A(n,k) Є θ(nk)
Hence time complexity of binomial coefficient is Θ(nk)
3. Explain the Warshall‟s Algorithm with an examples.[CO3 – H1 - Nov/Dec 2010]
Warshall‘s algorithm constructs the transitive closure of given diagraph with n vertices
through a series of n × n boolean matrices.
The computations in Warshall‘s algorithm are given by following sequence,
R(0), . . . , R(k−1), R(k), . . . R(n).
Thus the idea in Warshall‘s algorithm is building of boolean matrices.
Digraph : the graph in which all the edges are directed then it is called digraph or
directed graph .
Fig: Digraph

Adjacency matrix : it is a representation of a graph by using matxi. If there exists an

edge between the vertices Vi and vj directing from vi to vj then entry in adjacency matrix
in ith row and jth colums is 1
Edge from b to d
adjacency matrix.
Transitive closure : Transitive closure is basically a boolean matrix ( matrix with 0 and
1 values ) in which the existence of directed paths of arbitrary lengths between vertices
is mentioned.
transitive closure.
The transitive closure can be generated with Depth First Search (DFS) or with Breadh
First Search (BFS).
This traversing can be done on any vertex.
While computing transitive closure we have to start with some vertex and have to find
all the edges which are reachable to every other vertex . the reachable edges for all the
vertices has to obtained

Algorithm :
Algorithm Warshall ( matrix [1..n, 1..n]
//problem description : this algorithm is for computing
//transitive closure using warshall‘s algorithm
//input: the adjacency matrix given by matrix [ 1..n , 1..n]
//Output : the transitive closure of digraph

R(0 )← Matrix // initially adjacency matrix of

//diagraph becomes R(0 )
for (k ← 1 to n ) do
{
for (i ← 1 to n ) do
{
for (j ← 1 to n ) do
{
R(k) [ i, j] ← R(k-1) [ i, j] OR R(k-1) [ i, k]
AND R(k-1) [ k, j]
}}}
return R(n)
Analysis:
Clearly time complexity of above algorithm is Θ(n3) because in above algorithm the basic
operation is computation of R(k) [ i, j].
This operation is located within three nested for loops.
The time complexity warshall ‗s algorithm is Θ(n3)
V A B C d
A 0 ∞ 3 ∞
4. Explain the Floyd‟s algorithm with examples. [ CO3 – H1 - Nov/Dec 2011]

Floyd‘s algorithm is used for finding the shortest path between every pair of vertices of a
graph. It is all pairs shortest path algorithm.The algorithm works for both directed and
undirected graphs. This algorithm is invented by R. Floyd hence is the name.

B 2 0 ∞ ∞
C ∞ 7 0 1
D 6 ∞ ∞ 0
Weighted graph: the weighted graph is a graph in which weights or distances are given
along the edges. The weighted graph can be represented by weighted matrix as follows,
Here
w[i][j] = 0 if i=j
W[i][j] =∞ if there is no edge ( directed edge) between i
and j .
W[i][j] = weight of edge.
Formulation:
Let , Dk [i,j] denotes the weight of shortest path from vi to vj using {v1 , v2, v3…vk}
as intermediate vertices.
Initially D(k) is computed as weighted matrix
There exits two case –
1. A shortest path from vi to vj with intermediate vertices from {v1 , v2, v3…vk} that
does not use vk . in this case
Dk [i,j] = D(k-1)[i,j]
2. A shortest path from vi to vj restricted to using intermediate vertices {v1 , v2,
v3…vk} which uses vk. in this case-

Dk[i,j] = D(k-1) [i,k] + D(k-1) [k,j]

The graphical representation of these two case is shortest path using vertices
from {v1 , v2, v3…vk}
Basic concept of Floyd‟s algorithm:

1. The Floyd‘s algorithm is for computing shortest path between every pair of
vertices of graph.
2. The graph may contain negative edges but it should not contain negative cycles.
3. The Floyds algorithm requires a weighted graph.
4. Floyd‘s algorithm computes the distance matrix of a weighted graph with n
vertices through a series of n × n matrices :
D(0), . . . , D(k−1), D(k), . . . , D(n).
5. In each matrix D(k) the shortest distance ―dij‖ has to be computed between vertex
vi and vj
6. In particular the series starts with D(0) with no intermediate vertex. That means
D(0) is a matrix in which vi and vj i.e.ith row and jth column contains the weights
given by direct edges . in D(1) matrix – the shortest distance going through one
intermediate vertex ( starting vertex as intermediate) with maximum path length
of 2 edges is given continuing in this fashion we will compute D(n), contains the
lengths of shortest paths among all paths that can use all n vertices as
intermediate. Thus we get all pair shortest paths from matrix D(n)
Obtain the all pair – shortest path using Floyd‘s algorithm for the
following weighted graph,

Algorithm:
ALGORITHM Floyd(W[1..n, 1..n])
//Implements Floyd‘s algorithm for the all-pairs shortest-paths //problem
//Input: The weight matrix W of a graph with no negative-length //cycle
//Output: The distance matrix of the shortest paths‘ lengths
D ←W //is not necessary if W can be overwritten

for k←1 to n do
{
for i ←1 to n do
{
for j ←1 to n do
{
D[i, j ]←min{D[i, j ], D[i, k]+ D[k, j]}
}}}
return D
Analysis :
In the above given algorithm the basic operation is –
D[i, j ]←min{D[i, j ], D[i, k]+ D[k, j]}
This operation is within three nested for loops , we can write
C(n) = ∑ ∑
C(n) = ∑ ∑ therefore ∑
C(n) = ∑ ∑
C(n) = ∑ n2
C(n) = n3
The time complexity of finding all pair shortest path is Θ (n3)
5. Write the algorithm to compute the 0/1 knapsack problem using dynamic
programming and explain it. [ CO3 – L2 – Dec 2010]
Given n items of known weights W 1….. W n and values a knapsack of capacity W, find the
most valuable subset of the items that fit into the knapsack.
Assume that the weights and the knapsack capacity are positive integers.
The item values do not have to be integers.
To design a dynamic programming algorithm, it is necessary to derive a recurrence relation
that expresses a solution to an instance of the knapsack problem in terms of solutions to its
smaller sub instances.
The recurrence relation is, equation
The initial conditions are equation (2)

Our goal is to find F[n,w], the maximum value of a subset of the n items that fit into the
knapsack of capacity w, and an optimal subset itself.
F[0,j] = 0 as well as F[i,0] = 0 when j≥0 and i≥0.
The table can be filled by either row by row or column by column.
0 j- W i j W
0 0 0 0
W i Vi i-1 0 F[i-1,j- W i] F[i-1,j]
i 0 F[i,j]
n 0 Goal
Example
For the given instance of problem obtain the optimal solution for the knapsack problem
Item Weight
Value
1 2 $3
2 3 $4
3 4 $5
4 5 $6
The capacity of knapsack is W=5

Solution :
Initially , F[0,j] = 0 and F[ I,0] = 0.
There are 0 to n rows and 0 to W columns in the table.

0 1 2 3 4 5
0 0 0 0 0 0
0
0
1
2 0
3
0
4
0
Let us start filling the table row by row using following formula:
Compute F[1 , 1] with i = 1 , j= 1 , wi = 2 and vi =3

As j< wi we will obtain F[1,1] as
F[1,1] = F[ i – 1, j]
= F[ 0, 1]
F[1,1] = 0
As j≥ wi we will obtain F[1,2] as
F[1,2]= Max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max {F[ 0,2]) , ( 3 + F[ 0,0])}
= Max{ 0, 3 + 0}
F[1,2] = 3
F[1,3]= Max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max {F[ 0,3]) , ( 3 + F[ 0,1])}
= Max{0, 3 + 0}
F[1,3] = 3

F[1,4] = Max{ F[i -1,j],vi + F [i-1, j-wi]}

= Max {F[ 0,4]) , ( 3 + F[ 0,2])}
= Max{0, 3 + 0}
F[1,4]= 3
Compute F [1 , 5] with i = 1 , j= 5, wi = 2 and vi =3
F[1,5]= Max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max {F[ 0,5]) , ( 3 + F[ 0,3])}
= Max{0, 3 + 0}
F[1, 5]= 3
The table with these values can be
0 1 2 3 4 5
0 0 0 0 0 0 0
1
0 0 3 3 3 3
2
3 0
4
0
Compute F[2 , 1] with i = 2 , j= 1, wi = 3 and vi =4

As j≤ wi we will obtain F[2,1] as
F[2,1] = F[i – 1, j] = F[1, 1]
F[2,1] = 0
As j≤ wi we will obtain F[2,2] as
F[2,2] = F[i – 1, j]
= F[1, 2]
F[2,2] = 3

As j≥wi we will obtain F[2,3] as

F [2 , 3]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 1,3]) , ( 4 + F[ 1,0])}
= Max{ 3, 4+ 0}
F[2,3] = 4
As j≥wi , we will obtain F[2,4] as
F [2,4] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 1,4]) , ( 4 + F[ 1,1])}
= Max{ 3, 4+ 0}
F[2,4] = 4
F [2 , 5] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 1,5]) , ( 4 + F[ 1,2])}
= Max{ 3, 4+ 3}
F[2,5] = 7
0 1 2 3 4 5
0 0 0 0 0 0 0
1
0 0 3 3 3 3
2
3 4 4 7
3 0 0
4
0


F[3,1] = F[i – 1, j]
= F[2, 1]
F[3,1] = 0
Compute F [3 , 2] with i = 3 , j=2, wi = 4 and vi =5
As j<wi we will obtain F[3,2] as
F[3,2]= F[i – 1, j]
= F[2, 2]
F[3,2]= 3
F[3,3]= F[i – 1, j]
= F[2, 3]
F[3,3] = 4
F [3,4]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 2,4]) , ( 5 + F[ 2,0])}
= Max{ 4, 5+ 0}
F[3,4] = 5
Compute F [3 , 5 ] with i = 3 , j=5 wi = 4 and vi =5
F [3,5]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 2,5]) , ( 5 + F[ 2,1])}
= Max{ 7, 5+ 0}
F[3,5] = 7

F[4,1] = F[i – 1, j]
= F[3, 1]
F[4,1]= 0
F[4,2] = F[i – 1, j]
= F[3, 2]
F[4,2]= 3

Compute F [4 , 3] with i = 4 , j=3 wi = 5 and vi =6

F[4,3] = F[i – 1, j]
= F[3, 3]
F[4,3]= 4
F[4,4] = F[i – 1, j]
= F[3, 4]
F[4,4] = 5
F[4,5]= Max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 3,5]) , ( 6 + F[ 3,0])}
= Max{ 7, 6+ 0}
F[4,5]=7
Identification of Knapsack Items:

F[ n, W] is the total value of selected items that can be placed in the knapsack. Following
steps are used repeatedly.
Let i=n and k = W then
While ( i>0 and k>0)
{ If(F[i,k] ≠ F[i-1,k]) then
Mark ith item as in knapsack
i= i-1 and k=k-wi // selection of ith item
else
i= i-1 // do not select ith item }

Start : Let i = 4 and k = 5

Capacity ->0 1 2 3 4 5
0
0 0 0 0 0 0
1
2 0 0 3 3 3 3
3
4 3 4 4 7
0 0
As
0 0 3 4 5 7
0 0 3 4 5 7
F[i,k] = F[ i – 1, k]
F[ 4,5] = F[3,5] , Don‘t select i th item.
Now set i = i - 1, i = 3
Capacity -> 0 1 2 3 4 5
0 0 0 0 0 0 0
1
0 0 3 3 3 3
2
0 0 3 4 4 7
3
4 0 0 3 4 5 7
0 0 3 4 5 7

F[3,5] = F[2,5] Don‘t select ith item i.e ., 3 rd item . now set i = i-1, i=2
Capacity -> 0 1 2 3 4 5
0
0 0 0 0 0 0
1
0 0 3 3 3 3
2
3 0 0 3 4 4 7
4
0 0 3 4 5 7
0 0 3 4 5 7
F [i,k]≠ F[ i – 1, k] F[2,5] ≠ F[1,5] Select ith item, ie , select 2nd item.Set i = i -1 and k =
k- wi i.e . i = i -1, i=1 and k = 5 - 3 =2
Capacity -> 0 1 2 3 4 5
0 0
0 0 0 0 0
1
0 0 3 3 3 3
2
3 0 0 3 4 4 7
4 0 0 3 4 5 7
0 0 3 4 5 7
As F [i,k]≠ F[ i – 1, k]
i.e F[1,2] ≠ F[0,2]
select ith item

That is , select 1st item.

Set i = i - 1 and k = k – wi
i = 0 and k=2-2=0
Thus item 1 and item 2 are selected for the knapsack.
Algorithm
Algorithm Dynamic knapsack (n,, W,w[],v[])
// problem description : this algorithm is for obtaining knapsack
// solution using dynamic programming
//input : n is total number of items , W is the capacity of //knapsack, w [] stores weights
of each item and v[] stores
//the values of each item
//output : returns the total value of selected items for yhe
// knapsack
For(i← 0 to n ) do
{
for(i← 0 to W ) do
{
F[i,0] = 0 // table initialization
F[0,j] = 0
}}
for(i← 0 to n ) do
{ for(i← 0 to W ) do
{ If(j<w[i]) then
{ F[i,j] ←F[i – 1, j]
Else if (j>= w[i]) then
F[i,j] ←max(F[i -1,j],v[i] + F [i-1, j-w[i])
}}}
Return F[n,W]
Analysis:
In this algorithm the basic operation is if ….else if statement within two nested for loops
Hence
C(n) = ∑
0
C(n) =

C(n) =
∑
C(n) =
∑
C(n) = W.
C(n) = W( n- 0 +) + ( n-0+1)
C(n) = W n +W + n + 1
C(n) = W n
The time complexity of this algorithm is Θ( nW)
6. Explain 0/1 knapsack Memory function in detail. Or Explain knapsack problem

and memory function in detail. [ CO3 – L2 - May/June 2013]
Memory Function:The memory function technique seeks to combine strengths of the top
down and bottom up approaches to solving problems with overlapping subprograms of a
given problem and recording their solutions in a table.
Memorization: is a way to deal with overlapping subproblems in dynamic programming

.During memorization
1. After computing the solution to a subproblem , store it in a table
2. Make use of recursive calls.
The 0/1 knapsack memory function algorithm:
ALGORITHM MFKnapsack(i, j )
//Input: A nonnegative integer i indicating the number of the //first items
being considered and a nonnegative integer j //indicating the knapsack
capacity
//Output: The value of an optimal feasible subset of the first i //items
// Values[1..n], and table F[0..n, 0..W ] whose entries are //initialized with
−1‘s except for row 0 and column 0 initialized //with 0‘s
if F[i, j ]< 0
if j <Weights[i]
value←MFKnapsack(i − 1, j)
else
value←max(MFKnapsack(i − 1, j),
Values[i]+ MFKnapsack(i − 1, j −Weights[i]))
F[i, j ]←value

return F[i, j ]
Example
Apply the dynamic programming following instance of the knapsack problems and
solve. The instance is
Item Weight Value
1 2 $12
2 1 $10
3 3 $20
4 2 $15
Capacity W=5
Solution :
Initially , F[0,j] = 0 and F[ i,0] = 0.
There are 0 to n rows and 0 to W columns in the table.
0 0 0 0 0 0
Now we will fill up the table either row by row or column by Colum. Let us start filling the
table row by row using following formula:

Compute F [1 , 1] with i = 1 , j= 1 , wi = 2 and vi =12

F[1,1] = F[ i – 1, j]
=F[ 0, 1] = 0
F[1,2] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max{0, 12 + 0}
F[1,2] = 12
F[1,3] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max{ 0, 12 + 0}
F[1,3] = 12
F[1,4] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max{ 0, 12 + 0}
F [1, 4] = 12
F[1,5] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max{ 0, 12 + 0}
F [1,5]= 12
0 1 2 3 4 5
1 0 0 0 0 0 0
2
3 0 0 12 12 12 12
4
5 0


F[2,1] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max{ 0, 10 + 0}
F[2,1]= 10
F[2,2] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 1,2) , ( 10 + F[ 1,1])}
= Max{ 12, 10 + 0}
F[2,2] = 12
Compute F [2 , 3] with i = 2 , j= 3, wi = 1and vi =10
F [2 ,3] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 1,3) , ( 10 + F[ 1,2])}
= Max{ 12, 10+ 12}
F[2,3] = 22
F [2,4]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 1,4]) , ( 10 + F[ 1,3])}
= Max{ 12, 10+ 12}
F[2,4] = 22
F [2,5] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 1,5]) , ( 10 + F[ 1,4])}
= Max{ 12, 10+ 12}
F[2,5] = 22
0 1 2 3 4 5
0 0 0 0 0 0
0 0 12 12 12 12
0 10 12 22 22 22


F[3,1] = F[i – 1, j]
= F[2, 1]
F[3,1] = 10
F[3,2] = F[i – 1, j]
= F[2, 2]
F[3,2] = 12
F [3 , 3]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 2,3) , ( 20 + F[ 2,0])}
= Max{ 22, 20+ 0}
F[3,3] = 22
F [3 , 4]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 2,4]) , ( 20 + F[ 2,1])}
= Max{ 22, 20+1 0}
F [3 , 4] = 30
Compute F [3 , 5 ] with i = 3 , j=5, wi = 3 and vi =20
F [3,5] = max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 2,5]) , ( 20 + F[ 2,2])}
= Max{ 22, 20+ 12}
F [3 , 5] = 32
The table with these computed values will be

0 1 2 3 4 5
1 0 0 0 0 0 0
2
3 0 0 12 12 12 12
4
5
0 10 12 22 22 22
0 10 12 22 30 32

F[4,1] = F[i – 1, j]
= F[3, 1]
F[4,1] =1 0
F [4, 2]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 3,2]) , ( 15 + F[ 3,0])}
= Max{ 12, 15+ 0}
F[4,2] = 15
F [4, 3]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 3,3]) , ( 15 + F[ 3,1])}
= Max{ 22, 15+1 0}
F [4,3] = 25
F [4, 4]= max{ F[i -1,j],vi + F [i-1, j-wi]}
= Max { F[ 3,4]) , ( 15 + F[ 3,2])}
= Max{ 30, 15+1 2}
F [4 , 4] = 30
Compute F [4 , 5] with i = 4 , j=5 wi = wi = 2 and vi =15

F [4 , 5] = max{ F[i -1,j],vi + F [i-1, j-wi]}

= Max { F[ 3,5]) , ( 15 + F[ 3,3])}
= Max{ 32,156+ 22}
F [4 , 5] = 37
The table with these computed values will be

0 1 2 3 4 5
1 0 0 0 0 0 0
2
3 0 0 12 12 12 12
4
5 0 10 12 22 22 22
0 10 12 22 30 32
0 10 15 25 30 37
Therefore i = 4, k = 4
As F [i,k]= F[ I – 1, k]
i.e F[4,5] = F[3,5]
Select ith item i.e ., 4 th item .
Now set i = i-1 and k = k- wi
Therefore i=4-1= 3 and k = 5 – 2= 3
As F [i,k]= F[ I – 1, k]
i.e F[3,3] = F[2,3]
do not Select ith item i.e ., 3 rd item .
Therefore i =3-1 = 2 and k = 5 – 2= 3
As F [i,k]≠ F[ I – 1, k]
i.e F[2,3] ≠ F[1,3]
Select ith item i.e ., 2 nd item .
Therefore i =2-1 = 1 and k = 3 – 2= 2
As F [i,k]≠ F[ I – 1, k]
i.e F[1,2] ≠ F[0,2]
Select ith item i.e ., 1 st item .


Therefore i =1-1 = 0 and k = 2 – 2= 0
Thus solution to this knapsack problem is ( item 1 , item 2 , item 4 ) with
total profit = 3

Unit – 4
Iterative Improvement
Part - A
1. Describe feasible solution and feasible region? [CO4 – L2 - May 2012]
A solution that satisfies all the constraints of the problem is called the feasible
solution; the set of all such feasible points (solution) is called the feasible region.
Linear programming problems with the empty feasible region are called infeasible.
1.When the feasible region in linear programming becomes unbounded.
[ CO4 - L1 - May 2014]
If feasible region for the objective function may or may not attain a finite optimal
value, then such problems are called unbounded.
2.Define extreme point theorem. [ CO4 - L1 Nov/Dec 2010]

Any linear programming problem with a nonempty bounded feasible region has an
optimal solution; moreover, an optimal solution can always be found at an extreme
point of the problem‘s feasible region.
3.What are the requirements for the standard form of linear programming
problem? [ CO4 - L1]
The standard form has the following requirements:
It must be a maximization problem.
All the constraints (except the non negavity constraints) must be in the form of
linear equations with nonnegative right-hand sides.
All the variables must be required to be nonnegative.
4.Write the general linear programming problem in standard form.

[ CO4 - L1]
The general linear programming problem in standard form with m constraints and n
unknowns (n ≥ m) is
maximize c1x1 + . . . + cnxn
subject to ai1x1 + . . . + ainxn= bi,
where bi≥ 0 for i = 1, 2, . . . , m
x1 ≥ 0, . . . , xn≥ 0.
It can also be written in compact matrix notations:

maximize cx
subject to Ax = b
where x ≥ 0,
 x1   a11 a12  a1n
  b1

c = [c1 c2  cn], x =
 , A =  
x2
  , b =
 
b2
 
 am1 am2  amn 
 
 xn   bm 
5. What is basic and non basic solution? [ CO4 - L1]
If the system obtained has a unique solution—as any non degenerate system of
linear equations with the number of equations equal to the number of unknowns
does is called a basic solution; its coordinates set to zero before solving the system
are called nonbasic, and its coordinates obtained by solving the system are called
basic.
6. Define objective row. [ CO4 - L1 ]

The last row of a simplex table is called the objective row.
7. Define maximum flow problem. [ CO4 - L1]

The problem of maximizing the flow of a material through a transportation network
is called the maximum flow problem.
8. Define flow network. [ CO4 - L1]

A digraph satisfying the following properties is called a flow network or simply a
network.It contains exactly one vertex with no entering edges is called source and
assumed to be numbered 1.It contains exactly one vertex with no leaving edges is
called the sink and assumed to be numbered n.The weight uij of each directed edge
(i, j ) is a positive integer, called the edge capacity. (defines upper bound)
9. What is flow conservation requirement? [ CO4 - L1]

The total amount of the material entering an intermediate vertex must be equal to
the total amount of the material leaving the vertex is called the flow-conservation
requirement.

10. Define Max-Flow Min-Cut Theorem. [ CO4 - L1 ]

The value of a maximum flow in a network is equal to the capacity of its minimum
cut.
11. Define preflow. [ CO4 - L1 ]

A preflow is a flow that satisfies the capacity constraints but not the flow-
conservation requirement.
12. What is maximum cardinality matching? [ CO4 - L1]

A matching in a graph is a subset of its edges with the property that no two edges
share a vertex. A maximum matching also referred as maximum cardinality
matching is a matching with the largest number of edges.
13. Illustrate on bipartite graph. [ CO4 – L3]

In a bipartite graph, all the vertices can be partitioned into two disjoint sets V and U,
not necessarily of the same size, so that every edge connects a vertex in one of
these sets to a vertex in the other set.
14. Define stable marriage problem. [ CO4 - L1 - Dec 2015]

A marriage matching M is a set of n (m, w) pairs whose members are selected from
disjoint n-element sets Y and X in a one-one fashion, i.e., each man m from Y is
paired with exactly one woman w from X and vice versa. The stable marriage
problem is to find a stable marriage matching for men‘s and women‘s given
preferences.
.
16. Compose various applications of iterative improvement method? [
CO4 – H3 – Apr/May 2015]
Various application of iterative improvement method are-
1. Simplex method
2. Ford Flukersons algorithm for maximum flow
3. Matching of graph vertices.
4. Stable marriage problem.

17. Descibe linear programming problem? [ CO4 – L2]

The standard for of linear programming is- P=ax + by + cz
A linear programming (LP) problem is a problem in which we have to find the
maximum (or minimum) value of a linear objective function.
18. What is bipartite graph ? [ CO4 - L1]

The graph G = (V, E) in which the vertex set V is divided into two disjoint sets X and
Y in such a way that every edge e € E has one end point in X and other end point in
Y.
For example
19.What do you mean by perfect matching in bipartite graph? [ CO4 - L1]

A perfect matching is a matching which matches all vertices of the graph. That is,
every vertex of the graph is incident to exactly one edge of the matching. Figure (b)
above is an example of a perfect matching. Every perfect matching is maximum and
hence maximal. In some literature, the term complete matching is used. In the above
figure, only part (b) shows a perfect matching. A perfect matching is also a minimum-
size edge cover. Thus, ν(G) ≤ ρ(G) , that is, the size of a maximum matching is no
larger than the size of a minimum edge cover.

20.Define flow cut. [ CO4 - L1]
Definition. The capacity of an edge is a mapping c : E → R+, denoted by cuv or c(u,

v). It represents the maximum amount of flow that can pass through an edge.
Definition. A flow is a mapping f : E → R+, denoted by fuv or f (u, v), subject to the
following two constraints:
1. Capacity Constraint:
2. Conservation of Flows:
Definition. The value of flow is defined by
where s is the source of N. It represents the amount of flow passing from the source to
the sink.
Maximum Flow Problem. Maximize | f |, that is, to route as much flow as possible from
s to t.
Minimum cut
Definition. An s-t cut C = (S, T) is a partition of V such that s ∈ S and t ∈ T. The

cut-set of C is the set
Note that if the edges in the cut-set of C are removed, | f | = 0.
Definition. The capacity of an s-t cut is defined by
where if and , 0 otherwise.

PART B
1. Explain the simplex method with an example or linear programming. [ CO4 –

H1- Nov/Dec 2015]
The standard for linear programming is P=ax + by + cz
A linear programming(LP) problem is a problem in which we have to find the maximum
(or minimum) value of a linear objective function.
The desired largest (or smallest)value of the objective function is called the optimal
value and a collection of values of x,y,z,….that gives the optimal value constitutes an
optimal solution.
 The variable x,y,z,…are called the decision variables.
 A basic solution for which all variables are non negative is called a basic feasible
solution.
SIMPLEX METHOD:
Example 1: Consider following linear programming problem with two variables
-X+Y≤12
X+Y≤30
2X+y≤90
Find the maximum value of Z=4X+6Y where X≥0 and Y≥0
Solution:
Step1:Initial simple table
The given objective function is
Z=4X+6Y

convert to
-4x+6y+z=0
The given equations is linear programming form-
-X+Y=12
X+Y=30 These are called constraints
2X +y=90
We will write these equations in the form
-c1x1-c2x2-c3x3-……………cnxn+(0)s1+(0)s2+….z=0
-X + Y + S1 = 12
X + Y + S2 = 30
2X + 5Y + S3 = 90
The initial simplex table can be created as follows-
X Y S1 S2 S3 RHS
-1 1 1 0 0 12
1 1 0 1 0 30
2 5 0 0 1 90
-4 -6 0 0 0 0
 Here the basic variables are s1,s2 and s3 whereas the non basic variable are
X and Y.

 If we put x=0 and y=0 then we get s1=12,s2=30 and s3=90.

 Hence the basic feasible solution can be written as
o (x, y, s1, s2, s3) = (0, 0, 12, 30, 90)
 After setting up the initial simplex table the next task is to check the
optimality and then if current solution is not optimal, improve the current
solution.
 The improved solution is one that has a large z value than the current
solution, to improve the current solution we obtain new basic variable into
the solution.
 This variable is called the entering variable.
 This also implies that one of the current basic variable has to leave.
 This leaving variable is called departing variable.
 Following are points to remember.
1. The entering variable is the smallest negative entry in the
bottom row of the table.
2. The departing variable is the smallest negative ratio of
RHS/aij in the column determined by entering variable.
3. The intersection of entering variable’s column and departing
variable’s row is called Pivot. Make pivot value as 1 if it is not.
As the current solution (x, y, s1, s2, s3)=(0, 0,12, 30, 90) corresponds to z-
value of 0 …..(1)
x y S1 S2 S3 RHS
-1 1 1 0 0 12

1 1 0 1 0 30
2 5 0 0 1 90
Entering variable
-4 -6 0 0 0 0
 To locate departing variable
we apply min(RHS/yi}
 12/1=12 , 30/1= 30, 90/5=18
 The minimum value is with y1 and s1.hence departing variable is
s1. pivot
x y S1 S2 S3 RHS
s1 Departing
-1 1 1 0 0 12
variable
1 1 0 1 0 30
s2
2 5 0 0 1 90
s3
-4 -6 0 0 0 0
Entering variable
 Applying Gauss Jordan elimination method to obtain improved solution
x Y S1 S2 S3 RHS
-1 1 1 0 0 12
1 1 0 1 0 30
2 5 0 0 1 90

-4 -6 0 0 0 0
Will
make 0
by
gauss
Jordan
metho
Now the improved solution is

(x,y,s1,s2,s3)=(0,12,0,18,30)
x y S1 S2 S3 RHS
Replacing
y departing
-1 1 1 0 0 12
variable s1
s2 by y
2 0 -1 1 0 18
(i.e.entering
s3
7 0 -5 0 1 30 variable)
-10 0 6 0 0 72
Now y=12 and x remains 0 as it is.The value of z is,

z= 4x+6y = 4(0)+6(12) =72 …………..(2)
Now the improved solution which we have obtained in previous step is still not
optimal because bottom row has still a negative entry.
x y S1 S2 S3 RHS

-1 1 1 0 0 12
2 0 -1 1 0 18 y
7 0 -5 0 1 30 s2
-10 0 6 0 0 72 s3
Entering variable
To obtain departing variable-Min{12/-1,18/2,30/7}={-12,9,4}

The smallest non negative value is 4. Hence departing variable is s3.we will
divide third row by 7.
x y S1 S2 S3 RHS
-1 1 1 0 0 12
2 0 -1 1 0 18
7/7 0 - 0 1/7 30/7

5/7
-10 0 6 0 0 72
x y S1 S2 S3 RHS
-1 1 1 0 0 12

2 0 -1 1 0 18
1 0 - 0 1/7 30/7
5/7
-10 0 6 0 0 72
y
s2
s3
Now Matrix [s3,x] represent the pivot element.

Apply Gauss Jordan method.
x y s1 s2 s3 RHS
-1 1 1 0 0 12
2 0 -1 1 0 18 -1 1 1 0 0 12
1 0 - 0 1/7 30/7 2 0 -1 1 0 18
5/7
1 0 - 0 1/7 30/7
-10 0 6 0 0 5/7
72
0 0 -8/7 0 10/7
804/7
Multiple this row by 10

then add it with last row.
The resultant value will
be stored in last row
Similarly row 1 and row2 can be simplified. Now the simplex table will be
x y s1 s2 s3 RHS
0 1 2/7 0 1/7 114/7 y
0 0 3/7 1 -2/7 66/7 s2
1 0 -5/7 0 1/7 30/7 x
0 0 -8/7 0 10/7 804/7

The solution is (x,y,s1,s2,s3)=(30/7,114/7,0.66/7,0)

z=4x+6y =4(30/7) + 6(114/7) = 115 … 3)
Now we will have s1 as entering variable-
To locate departing variable
min 114/7 66/7 30/7
2/7 3/7 -5/7
={57,22,-6}
We get s2 as departing variable.The pivot will now be 3/7 continuing in this fashion
after some iterations we will eliminate negative values from bottom row.
The simple table will then be-
0 1 0 -2/3 1/3 10
0 0 1 7/3 -2/3 66/3 Y
1 0 0 5/3 -1/3 20 S1
0 0 0 8/3 2/3 980/7 X

x y s1 s2 s3 RHS
The option solution will be
(x,y,s1,s2,s3)= (20,10,66/3,0,0 )
Z=4x+6y =4(20)+6(10) =140 ………(4)
Thus we moved on with
(0,0) (0,12) (30/7,114/7) (20,10)
With z=0 z=72 z=115 z=140
The graph for representing feasible solution region will
feasible
region(20,10)
(0, 12)
10
5
(0,0)
5 10 15 20 25 (30, 0)
2. Explain and solve the maximum flow problem. [ CO4 – H1 - Dec 2015]
The maximum flow problem
Maximum flow is a maximum feasible flow between source and sink. Here the word
flow means the rate at material moves through underlying object.But when the material
moves through some object it is very much essential to consider its capacity.In
maximum flow problem , we want to compute the greatest rate at which material can be
moved or travelled from source to sink without violating any capacity constraint. There
are many algorithm that can find out the maximum flow from a given network. We will
discuss one efficient and simple algorithm named ford-flukerson for finding the
maximum flow.Let us now define some basic terminologies of flow networks.
Flow Network:
The flow network can be define by graph G=(V,E) which is a directed graph with
edge(u,v)€E. The edge (u,v) has non-negative capacity denoted by c(u,v)≥0iIf c(u,v)=0.

There are two distinguishing nodes in flow network called source and sink through
which the material moves. That means a flow is from source to sink.
There are three important properties of flow networks.
1.Capacity constraint: For all u,v€ V the flow of edge(u,v) is always less than or
equal to the capacity of that edge(u,v).i.e. f(u,v)≤c(u,v).
2.Skew symmetry : Forall u,v € v f(u,v)= -f(v,u), that means reverse edge.
3.Flow conservation: For any vertex v except s,t i.e. source and sink
respectively.
∑ f(u,v)=0
v€V
The value of flow from u to v can be defined as
│f│=∑f(s,v)
v€V
For example
3
7 5
8 3
s 2 t
2 4 6
1 3 4
Flow network G=(V,E) with capacity shown along the edges:

3 F(u,v)
5/7 5/5 c(u,v)
3/3
7/8 t
s 2
4/4 5/6
2/3
1 4
This algorithm works for solving maximum-flow problem.

This is an iterative method .the ford-fulkerson algorithm makes use of 3 important things
 Residual network
 Augmenting path
 Cuts
1. Residual network
Suppose we have a flow network G=(V,E) with source s and sink t.
Let every edge u,v is having a pair flow/capacity then representation of a graph with
residual capacity is called residual network.
Cf(u,v)= c(u,v)-f(u,v)
3 F(u,v)
5/7 5/5 c(u,v)
3/3
7/8 t
s 2
4/4 5/6
2/3
1 4

2. The augmenting path

Cf(u,v)=c(u,v)-f(u,v)
=7-5
Cf(u,v) =2
5 2 5
3
1
7 t
5 1
s 2 4/4
2 1
2
4
1 Fig: Residual graph

An augmenting path is a simple path p from s to t in residual network G f. This

is the path which never violates the capacity constraints.The graph is in
maximum flow if there is no augmenting path.
3. Cuts in Flow Networks

Cuts is a collection of arcs such that if they are removed there is no path from
s to t
A D
15/20
7/8 17/19
S
T
12 7 4/8
B C
5/7 12/14 3/3

Cut
A cut is said to be minimum in a network whose capacity is minimum over
all cuts of the network.
Ford-fulkerson method
Algorithm ford-fulkerson(G,s,t)
{
// Problem statement: This algorithm obtain a graph in
// max flow condition. Here s represents source and t //represents sink
node. Let f be the flow initialize flow f to 0.
While there exists an augmenting path p
{
Augment flow f for path p.
}
Return f
}// end of algorithm..

Step 1:
o The augmenting path is marked by thick line.
o This is a path which gives maximum flow.
o Now we will find the residual capacity cf(p).
o Find out the minimum value along the residual path.
o Here it is 4 i.e. c(2,4).
o Now we will design a residual graph by considering residual
capacity 4.
7 5
t
s 2
8 3
2 2 4 4 6
3
Step2: here along the augmenting path the residual capacity is c(3,t) =5 . hence
we can draw residual network.
Step3: now we will again mark augmenting path for maximum flow.
Here cf=c(2,3) =3
Hence the residual graph is as follow:
This is the residual graph, we will now find the augmenting path giving maximum
flow from source to sink. Here the only remaining path is s-1-4-t.
The cf=(s,1)=2

Step 4:
Step 5: Now there is no path from s to t in following graph, hence we will exit the
while loop.
Hence the graph marked by thick line in step 4 is a maximum flow.

Now once again consider the original graph which we have taken for discussing above
exampl
Cut = {(s,3),(s,2),(s,1)}
When the graph has maximum flow then it gives minimum cut which is as shown
below.

Analysis : The algorithm for Ford-Fulkerson has a while loop which executes for O
(E). Hence running time of Ford-Fulkerson algorithm is O(EF*) where F* is the
maximum flow found b algorithm.
3. Explain the Maximum Matching in Bipartite Graph algorithm with supporting
example [ CO4 – L2 – Apr/May 2015]
Bipartite Graph:
The graph G = (V, E) in which the vertex set V is divided into two disjoint sets X and Y in
such a way that every edge e € E has one end point in X and other end point in Y.
For example

Matching:
A matching M is a subset of edges such that each node in V appears in at most one
edge in M. In other words matching in a graph is a subset of edges that no two edges
share a vertex.
Two-colorable Graph:
A graph can be colored with only two colors (i.e. two colorable graph) such that no edge
connects the same color. The bi-partite graph is 2-colorable.
Free vertex:
µ € V is a fee vertex, if no edge from matching M os incident to v (that means if v is not
matched).
Alternating path:
The alternating path P is a path in graph G, such that for every pair of subsequent
edges one of them is matching pair M and other is not.
Augmenting path:
The augmenting path P is a path in graph G, such that it is an alternating path with
special property that its start and end vertices are free or unmatched.
Maximum matching or Maximum cardinality matching:
It is a matching with largest number of matching edges.
Maximum matching problem is a problem of finding maximum

matching in a graph.
Let us apply iterative-improvement technique to maximum matching problem.

Let M be a matching in bipartite graph G.

Here the vertices D, 3, E and 4 are matched and vertices A, 1, B, 2, c, 5 are free or
unmatched vertices.
By adding a pair (A, 2) for matching
We get larger matching Ma
Something to get larger matching, for inclusion of some pair, we may need removal of
existing pair. Such a matching adjustment is called augmentation.
Following figures illustrate this concept

Thus we have got maximum matching. This is also called as perfect matching
because all vertices of graph are matched.
Theorem:
A matching M is a maximum matching if and only if there exists no augmenting
path with respect to M.
Algorithm Maximum Bipartite Matching(G)
initialize set M of edges // can be the empty set
initialize queue Q with all the free vertices in V
while not Empty (Q) do
w < Front(Q)
if w ε V then
for every vertex u adjacent to w do // u must be in U
if u free then // initialize set M of edges // can be the empty set
initialize queue Q with all the free vertices in V

while not Empty (Q) do

w < Front(Q)
if w ε V then
for every vertex u adjacent to w do // u must be in U
augment
M< M union (w, u)
v< w
while v is labeled do // follow the augmenting path
u< label of v
M< M – (v, ) // (v, u) was in pervious M
V< label of u
M< M union (v, u) // add the edge to the path
// start over vertex labels
reinitialize Q with
remove all
all the free vertices in V
break // exit for loop
else// u is matched
if (w, u) not in M and u is unlabeled then
label u with w // represents an edge in E-M
Enqueue(Q, u)
// only way for a U vertex to enter the queue
else // w ƹ U and therefore is matched with v

V <w‘s mate // (w, v) is in M

Label v with w // represents in M
Enqueue(Q, v) // only way for a mated v to enter Q
Return M // maximum matching
Application of Algorithm
Step 1:
Step 2:
Step 3: Augmenting from 2

Step 4: Augmenting from 5
Step 5:
This is also a perfect matching.

Example : Apply the maximum matching algorithm to Following bi-partite graph.
Solution:
Step 1: Step 2:
Step 3: Step 4:
Step 5: Step 6:

Step 7:
4. Briefly describe on the stable marriage problem. [ CO4 – L2]

Consider two sets M={m1, m2,…,mn} of n men and W={w1,w2,…,wn} of n women.
Each man has a preference list ordering the women as potential marriage partners with
no ties allowed. Similarly, each woman has a preference list of the men, also with no
ties. Then we have to find out the marriage matching pair (m, w) whose members are
selected from these two sets based on their preferences.
There is a set Y = {m1,…,mn} of n men and a set X = {w1,…,wn} of n women. Each man
has a ranking list of the women, and each woman has a ranking list of the men (with no
ties in these lists).
A marriage matching M is a set of n pairs (mi, wj).
A pair (m, w) is said to be a blocking pair for matching M if man m and woman w are not
matched in M but prefer each other to their mates in M.

A marriage matching M is called stable if there is no blocking pair for it; otherwise, it‘s
called unstable.
The stable marriage problem is to find a stable marriage matching for men‘s and
women‘s given preferences.
An instance of the stable marriage problem can be specified either by two sets of
preference lists or by a ranking matrix, as in the example below.
men‘s preferences women‘s preferences
1st 2nd 3rd 1st 2nd 3rd
Bob: Lea Ann Sue Ann: Jim Tom Bob
Jim: Lea Sue Ann Lea: Tom Bob Jim
Tom: Sue Lea Ann Sue: Jim Tom Bob
ranking matrix
Ann Lea Sue
Bob 2,3 1,2 3,3
Jim 3,1 1,3 2,1
Tom 3,2 2,1 1,2
{(Bob, Ann) (Jim, Lea) (Tom, Sue)} is unstable

{(Bob, Ann) (Jim, Sue) (Tom, Lea)} is stable
Freemen:Bob, Jim, Tom
Ann Lea Sue
Bob 2,3 1,2 3,3
Jim 3,1 1,3 2,1
Tom 3,2 2,1 1,2

Bob proposed to Lea

Lea accepted
Freemen: Ann Lea Sue

Jim, Tom
Jim proposed to Lea Bob 2,3 1,2 3,3
Lea rejected
Jim 3,1 1,3 2,1
Tom 3,2 2,1 1,2
Freemen: Ann Lea Sue

Jim, Tom
Bob 2,3 1,2 3,3
Jim proposed to Sue
Sue accepted
Jim 3,1 1,3 2,1
Tom 3,2 2,1 1,2
Ann Lea Sue
Bob 2,3 1,2 3,3
Freemen: Tom
Jim 3,1 1,3 2,1
Tom proposed To Sue Sue rejected
Tom 3,2 2,1 1,2

Freemen:
Tom Ann Lea Sue
Tom proposed to Lea
Lea replaced Bob with Tom Bob 2,3 1,2 3,3
Jim 3,1 1,3 2,1
Tom 3,2 2,1 1,2
Ann Lea Sue

Freemen:
Bob
Bob 2,3 1,2 3,3
Jim 3,1 1,3 2,1

Bob proposed to Ann
Ann accepted
Tom 3,2 2,1 1,2
The algorithm terminates after no more than n2 iterations with

a stable marriage output
The stable matching produced by the algorithm is always man-optimal: each man gets
the highest rank woman on his list under any stable marriage. One can obtain the
woman-optimal matching by making women propose to men
A man (woman) optimal matching is unique for a given set of participant preferences
Algorithm
Step 1: Initially all the men and all the women are free, but having their preferences list
with them.
Step 2:
Propose: One of the free man m proposes to women w. This woman is normally
the highest preferred one from his preference list.
Response: If the woman w is free then she accepts the proposal of matched m.
If she is not free, she compares the m with her current mate. If she prefers m with
current mate then she accepts his proposal making former mate free otherwise
simply rejects m‘s proposal.
Step 3: Finally , returns the matching pairs of (m,w)

5. Maximize p=2x+3y+z<=40
2x+y-z>=10
-y+z>=10
x>=0,y>=0,z>=0. [ CO4 – L3 - May/June 2015]
General maximization problems are linear programming problems in which you
are asked to maximize an objective function. It may be non-standard: one or more
of the constraints may be a constraint.
Rewrite the following LP problem as a system of linear equations.
Maximize p = 2x + 3y + z subject to
x + y + z 40
2x + y - z 10
- y + z 10
x 0, y 0, z 0
Use slack or surplus variables s, t and u respectively, and type all equations with the
variables in the order shown above
The first constraint is x + y + z 40.
To turn it into an equation, we must add a slack variable s to the left-hand side,
getting x + y + z + s = 40.
The next constraint is 2x + y - z 10,
and we must subtract the surplus variable t to the left-hand side, getting
2x + y - z - t = 10.
The last constraint is - y + z 10,
and we must subtract the surplus variable u to the left-hand side, getting
- y + z - u = 10.
Finally, the objective is p = 2x + 3y + z.
We must subtract 2x + 3y + z from both sides to get the desired equation:
-2x - 3y - z + p = 0.
Step 2: Set up the initial tableau.
Step 1 We convert the LP problem into a system of linear equations by putting in the
slack variables and rewriting the objective function:
x + y + z + s = 40
2z + y - z - t = 10
- y + z - u = 10

3y z + p = 0
2x
Thus, the initial tableau is as follows.
x y z s t u p Ans
s 1 1 1 1 0 0 0 40
t 2 1 -1 0 -1 0 0 10
u 0 -1 1 0 0 -1 0 10
p -2 -3 -1 0 0 0 1 0
The current tableau is
x y z s t u p Ans
s 1 1 1 1 0 0 0 40
t 2 1 -1 0 -1 0 0 10
u 0 -1 1 0 0 -1 0 10
p -2 -3 -1 0 0 0 1 0
Reading across the first row (active variable s), we find s = 40/1 = 40.
Reading across the second row (active variable t), we find t = 10/(-1) = -10.
Reading across the third row (active variable u), we find u = 10/(-1) = -10.
Reading across the bottom row (active variable p), we find p = 0/1 = 0
Since all the other variables are inactive, their values are zero.
Notice that the values of the surplus variables t and u are currently negative. This is
not permitted, since all variables are required to be non-negative. This tells us that
the current basic solution (x, y, z) = (0, 0, 0) is not feasible, (it does not satisfy the
second and third constraints). We use asterisks to mark the rows corresponding to
those negative basic variables:

x y z s t u p Ans
s 1 1 1 1 0 0 0 40
*
2 1 -1 0 -1 0 0 10
t
*
0 -1 1 0 0 -1 0 10
u
p -2 -3 -1 0 0 0 1 0
Our first order of business is to get into the feasible region, or, equivalently,
Phase I: Get rid of the stars.
We can (eventually) get rid of all the stars by pivoting one or more times. The only way
this differs from the procedure for pivoting in standard maximization
problems is the way in which we select the pivot column.
 For standard maximization problems, the pivot column was chosen by selecting
the most negative number in the bottom row.
 In Phase I, on the other hand, the pivot column is chosen by selecting the largest
positive number in the first starred row.
x y z s t u p Ans
Test ratio 40/1 =

s 1 1 1 1 0 0 0 40
40
10/2=5
*t 2 1 -1 0 -1 0 0 10 (Smallest).
*u 0 -1 1 0 0 -1 0 10
p -2 -3 -1 0 0 0 1 0

x y z s t u p Ans
s 0 1 3 2 1 0 0 70
X 2 1 -1 0 -1 0 0 10
*u 0 -1 1 0 0 -1 0 10
p 0 -2 -2 0 -1 0 1 10
which is no longer negative! Thus, we have eliminated one of the stars.

Since there is still one starred row left, we are not done with Phase I.
From the above curent table
Since Row 3 is the only starred row (and so it is the first starred row) we locate the
largest positive number in Row 3 (it is the "1" in the z-column), giving us the pivot
column (shown in red):
x y z s t u p Ans
Test Ratio:
s 0 1 3 2 1 0 0 70
70/3
X 2 1 -1 0 -1 0 0 10
Test Ratio:
*u 0 -1 1 0 0 -1 0 10 10/1
p 0 -2 -2 0 -1 0 1 10
Since the smallest test ratio is in the u-row (Row 3), we select the entry in Row 3
Column 3 as pivot. Using the correct pivot, now obtain the second tableau.
x y z s t u p Ans
s 0 1 3 2 1 0 0 70 R1-3R3
X 2 1 -1 0 -1 0 0 10 R2+3R3

*u 0 -1 1 0 0 -1 0 10
p 0 -2 -2 0 -1 0 1 10 R4+2R3
x y z s t u p Ans
s 0 4 0 2 1 3 0 40
X 2 0 0 0 -1 -1 0 20
Z 0 -1 1 0 0 -1 0 10
p 0 -4 0 0 -1 -2 1 30
The basic solution we now get from Row 3 is z = 10/1 = 10,

which is no longer negative, so the star disappears.
x y z s t u p Ans
Y 0 4 0 2 1 3 0 40
X 2 0 0 0 -1 -1 0 20
Z 0 0 4 2 1 -1 0 80
p 0 0 0 0 0 1 1 70

Unit – 5
Coping With The Limitations Algorithm Power
Part - A
1. Define Lower bound. [ CO4 - L1]  

Lower bound: an estimate of a number of operations needed to solve a given problem.
2. Define Tight Lower bound. [ CO4 - L1]

Tight Lower Bound: There exists an algorithm with the same efficiency as the lower
bound
3. List some examples Lower bound. [ CO4 - L1]

number of comparisons needed to find the largest element in a set of n numbers
number of comparisons needed to sort an array of size n
number of comparisons necessary for searching in a sorted array
number of multiplications needed to multiply two n-by-n matrices
4. What are the methods for Establishing Lower Bounds? [ CO4 - L1 ]

trivial lower bounds
information-theoretic arguments (decision trees)
adversary arguments
problem reduction
5. What is Trivial lower bound? [ CO4 - L1]

Trivial lower bounds is based on counting the number of items that must be processed
in input and generated as output
Examples
finding max element -- n steps or n/2 comparisons
polynomial evaluation
sorting
element uniqueness
Hamiltonian circuit existence.
6. What do you mean by decision trees. [ CO4 - L1 - May/June 2012]

A decision tree is a decision support tool that uses a tree-like graph or model of
decisions and their possible consequences, including chance event outcomes, resource
costs, and utility. It is one way to display an algorithm.Decision trees are commonly
used in operations research, specifically in decision analysis, to help identify a strategy
most likely to reach a goal.
7. What is knapsack? [ CO4 - L1 - May/June 2015]

The knapsack problem, another well-known NP-hard problem.The Knapsack problem
is, given n items of known weights w1, . . . , wn and values v1, . . . , vn and a knapsack of
weight capacity W, find the most valuable subset of the items that fits into the knapsack.
8. Define tractable. [ CO4 - L1]

Problems that can be solved in polynomial time are called tractable.
9. Define intractable. [ CO4 - L1]

Problems that cannot be solved in polynomial time are called intractable.
10. Define NP Hard and NP Completeness[ CO4 - L1 – Nov/Dec 2010]

NP Hard
A problem L is NP hard if and only if, statisialibility reduces to L.
NP complete
A problem L is complete iff L is NP hard and L Є NP
If L Є {0,1} X in NP complete if
L Є NP
al time readable to L for only LЄ NP
11. What is meant by class p? [ CO4 - L1 - May 2011]

It is deterministic in nature ‗
Solved by conventional computers in polynomial time
It takes the following time complexity
O(1) - constant
O(log n) - sun linear
O(n) - linear
O(n log n) - nearly linear
2
O(n ) - quadratic
It takes polynomial upper and lower bound.

12. Differentiate between decision and optimization problem. [ CO4 – L2 -

May/June 2015]
Decision Optimization problem.
Computational problem with intended output
Computational problem where we try to
of yes or No (i.e.,) 1 or 0 maximize or minimize the objective
function.
13. Define COOK‟S theorem. [ CO4 - L1 - May/June 2011]

Satisfiability is in P if and only if P = NP.
14. Define SATISFIABILITY. [ CO4 - L1]

Let x1, x2, x3….,xn denotes Boolean variables. Let xi denotes the relation of xi. A literal
is either a variable or its negation.
A formula in the prepositional calculus is an expression that can be constructed using
Literals and the operators and ^ or v. A clause is a formula with at least one positive
literal. The satiability problem is to determine if a formula is true for some assignment of
truth values to the variables.
15. State the property of NP-Complete problem. [ CO4 - L1 - May 2010/Dec 2013]
A problem L is completer if and only if L is NP-hard and L € NP
16. What are the factors that influence the efficiency of the backtracking
algorithm? [ CO4 - L1 - May/June 2015]
The efficiency of the backtracking algorithm depends on the following four
factors. They are:
The time needed to generate the next xk
The number of xk satisfying the explicit constraints.
The time for the bounding functions Bk
The number of xk satisfying the Bk.
17. State 8 – Queens problem. [ CO4 - L1 – Nov/Dec 2011]

The problem is to place eight queens on a 8 x 8 chessboard so that no two queen
―attack‖ that is, so that no two of them are on the same row, column or on the diagonal.
18. State Sum of Subsets problem. [ CO4 - L1 - Nov/Dec 2011]

Given n distinct positive numbers usually called as weights, the problem calls for
finding all the combinations of these numbers whose sums are m.
19. State m – Colorability decision problem. [ CO4 - L1]

Let G be a graph and m be a given positive integer. We want to discover whether
the nodes of G can be colored in such a way that no two adjacent nodes have the
same color yet only m colors are used.
20. Define bounding function. [ CO4 - L1]

Backtracking is to build up the solution vector one component at a time and to use
modified criterion function Pi(x1,…….xi) (sometimes called bounding function) to test
whether the vector being formed has any chance of success. Desired solution
expressed as an n-tuple (x1, x2,…….xn) where xi are chosen from some set Si.
If |Si|= mi m=m1, m2,………mn candidates are possible
Yielding the same answer with far fewer than m trials
Advantage: if it is realized that the partial vector (x1,…….xi) can in no way lead to an
optimum solution, then mi+1,… mn, possible test vectors can be ignored entirely.‖
21. Give the categories of the problem in backtracking. [ CO4 - L1 - Nov/Dec 2013]
Decision‘s problem: - Whether there is any feasible solution.
Optimization problem: - Whether there exists any best solution.
Enumeration problem: - Finds all possible feasible solution.
22. List down the examples of backtracking.[ C04 - L1 - May/June 2012]

The 8 - Queens problem
Hamiltonian cycles
Sum of Subsets
Graph Coloring
Knapsack Problem.
23. Define promising and non promising node. [ CO4 - L1 - Nov/Dec 2013]
Promising Node
A node in a state space tree is said to be promising if it corresponds to a partially
constructed solution that may still lead to a complete solution.
Non – Promising node
A node in a state space tree is said to be non-promising if it corresponds to a partially
constructed solution that would not be able to lead to a complete solution further.

24. What are the two types of constraints used in Backtracking?

[ CO4 - L1]
Explicit constraints
Implicit constraints
25. Define implicit constraint. [ CO4 - L1 - Nov/Dec 2012]

Implicit constraints are rules that determine which of the tuples in the solution
space of I that satisfy the criterion function.
Implicit constraints describe the way in which the xi is must relate to each other.
26. Define explicit constraint. [ CO4 - L1 - Nov/Dec 2012]

Explicit constraints are rules that restrict each xi to take on values only from a given set.
Explicit constraints depend on the particular instance I of problem being solved
All tuples that satisfy the explicit constraints define a possible solution space for I
Examples of explicit constraints:
xi >= 0, or Si = {all nonnegative real numbers}
xi = {0, 1} or Si = { 0, 1 }
li ≤ xi ≤ ui or Si = {a : li ≤ a ≤ ui }
27. How can you represent the solution for 2 queen‟s problem? [ CO4 - L1 -
May/June 2012]
There is no solution for 2 Queen‘s problem since however the queens are arranged
both queens would be in same diagonal or column.
28. How can you represent the solution for 8 queen‟s problem? [ CO4 - L1 -
May/June 2014]
All solutions represented as 8-tuples (x1, x2,…, x8) where xi is the column on which
queen ―i‖ is placed.
Constraints are,
Explicit constraints
Si = {1, 2, 3, 4, 5, 6, 7, 8}
Implicit constraints
No two xi‗s can be the same column or row.
No two queens can be on the same diagonal.
29. Define n-queens problem Or Give the formal definition of n- queens

problem [ CO4 - L1 - May/June 2008]

Place n queens on an nXn chessboard so that no queen attacks another queen
which means no two queen‘s are in same row/column or same diagonal solution space
consists of all n! Permutations of the n-tuple (1, 2 . . . n)
30. Describe the sum of subsets problem? [ CO4 – L2 - May 2013]

In the Sum-of-Subsets problem, there are n positive integers (weights) wi and a positive
integer W.
The goal is to find all subsets of the integers that sum to W.
For example, n = 4, w = (11, 13, 24, 7), and m = 31, the desired subsets are
(11, 13, 7) and (24, 7)
The solution vectors can also be represented by the indices of the numbers as
(1, 2, 4) and (3, 4).
All solutions are k-tuples, 1 ≤ k ≤ n
PART-B
1.Explain the lower bound arguments. [ CO4 – L2]

Lower Bound:
Estimating minimum amount of work needed to solve a problem.
There are various method of establishing lower bound
 Trivial Lower Bounds
 Information-Theoretic Arguments
 Adversary Arguments
 Problem Reduction
Trivial Lower Bounds

The simplest method of obtaining a lower-bound class is based on counting the number
of items in the problem‘s input that must be processed and the number of output items
that need to be produced. Since any algorithm must at least ―read‖ all the items it needs
to process and ―write‖ all its outputs, such a count yields a trivial lower bound.The trivial
lower bound for ‗ generating all permutations of n number‘ will be O(n!) this is because
the size of output is n! As another example, consider the problem of evaluating a
polynomial of degree n
p(x) = a n xn + an−1xn−1 + . . . + a0 at a given point x, given its coefficients an, an−1, .
. . , a0.

This lower bound is tight because both the right-to-left evaluation algorithm and
Horner‘s rule are both linear.
Similarly for ‗ product of two n × n matrices algorithm‘ the trivial lower bound is Ω(n2)
because in this algorithm2 n2 elements ( input) are to be processed and n2 element
get produced as an output.
Problem in this method
Trivial lower bounds are often too low to be useful. For example, the trivial bound for the
traveling salesman problem is Ω(n2), because its input is n(n − 1)/2 intercity distances and
its output is a list of n + 1 cities making up an optimal tour.
 But this bound is all but useless because there is no known algorithm with the
running time being a polynomial function of any degree.
 There is another obstacle to deriving a meaningful lower bound by this method. It lies
in determining which part of an input must be processed by any algorithm solving the
problem in question.
 For example, searching for an element of a given value in a sorted array does not
require processing all its elements.
Information-Theoretic Arguments
This method is a lower bound based on the amount of information it has to produce by
algorithm.
For example: Consider a game of guessing number ―, first of all think of some number
from 1 to n. find answer by asking questions. Answers can be either yes or no. Let us
encode number by [log2 n], bits.
Each answer will give information about each bit for instance.
Is first bit zero ? --> No = 1
Is Second bit zero ? --> yes = 0
Is third bit zero ? --> yes = 0 => the numbers is 8
(encoded in binary
form)
Is forth bit zero ? --> yes = 0
Consequently, any such algorithm will need at least [log2 n] such steps before it can
determine its output in the worst case.
The approach we just exploited is called the information-theoretic argument because of its
connection to information theory.

It has proved to be quite useful for finding the so-called information-theoretic lower
bounds for many problems involving comparisons, including sorting and searching.
Adversary Arguments
Adversary argument is a method of proving lower bound by playing a role of adversary
in which algorithm has to work more for adjusting input consistently.
For example: consider a ― game of guessing a number ― between 1 and n with yes / no
questions.
Adversary:
When adversary gives the answer one can get a larger set of number from which a
secret number has to be found out.
This algorithm needs [log2 n] iterations to reduce the set of n elements to single
element. That also implies that [log2 n] questions in worst case.
This example illustrates the adversary method for establishing lower bounds.
A lower bound is obtained by measuring the amount of work needed to shrink a set of
potential inputs to a single input along the most time-consuming path.
Example, Consider the problem of merging two sorted lists of size n
a1< a2 < . . . < an and b1< b2 < . . . < bn
into a single sorted list of size 2n. For simplicity, we assume that all the a‘s and b‘s are
distinct, which gives the problem a unique solution.
The number of key comparisons in the worst case for this algorithm for merging is 2n −
1.
Problem Reduction
Getting an algorithm for problem P by reducing it to another problem Q solvable with a
known algorithm.
A similar reduction idea can be used for finding a lower bound. To show that problem P
is at least as hard as another problem Q with a known lower bound, we need to reduce
Q to P (not P to Q!).

In other words, we should show that an arbitrary instance of problem Q can be

transformed (in a reasonably efficient fashion) to an instance of problem P, so any
algorithm solving P would solve Q as well. Then a lower bound for Q will be a lower
bound for P. Table 11.1 lists several important problems that are often used for this
purpose
TABLE
Problems often used for establishing lower bounds by problem reduction
Problem Lower bound Tightness

sorting Ω(n log n) yes
searching in a sorted array Ω(log n) yes
element uniqueness problem Ω(n log n) yes
multiplication of n-digit integers Ω(n) unknown
multiplication of n × n matrices Ω(n2) unknown
The element uniqueness problem asks whether there are duplicates among n given
numbers.
As an example of establishing a lower bound by reduction, let us consider the
Euclidean minimum spanning tree problem: given n points in the Cartesian plane,
construct a tree of minimum total length whose vertices are the given points. As a
problem with a known lower bound, we use the element uniqueness problem. We
can transform any set x1, x2, . . . , xn of n real numbers into a set of n points in the
Cartesian plane by simply adding 0 as the points‘ y coordinate:
(x1, 0), (x2, 0), . . . , (xn, 0).
Let T be a minimum spanning tree found for this set of points. Since T must contain
a shortest edge, checking whether T contains a zero length edge will answer the
question about uniqueness of the given numbers. This reduction implies that _(n log n)
is a lower bound for the Euclidean minimum spanning tree problem, too.
Since the final results about the complexity of many problems are not known, the
reduction technique is often used to compare the relative complexity of problems.

For example, the formulas
x.y=
and
x2 = x . x
Show that the problems of computing the product of two n-digit integers and
squaring an n-digit integer belong to the same complexity class, despite the latter
being seemingly simpler than the former.
There are several similar results for matrix operations. For example, multiplying two
symmetric matrices turns out to be in the same complexity class as multiplying two
arbitrary square matrices. This result is based on the observation that not only is the
former problem a special case of the latter one, but also that we can reduce the
problem of multiplying two arbitrary square matrices of order n, say, A and B, to the
problem of multiplying two symmetric matrices
0
X=[ ]
0
and
0
y=[ ]
0
where AT and BT are the transpose matrices of A and B (i.e., AT [i, j ]= A[j, i]and BT [i, j
]= B[j, i]), respectively, and 0 stands for the n × n matrix whose elements are all zeros.
0 0
Indeed,X Y= [ ] [ ]
0 0
0
=[ ]
0
from which the needed product AB can be easily extracted.
2. Explain Decision tree technique for searching a sorted array and

sorting algorithm. [ CO4 – L2]
All the sorting and searching algorithms are based on comparison method.
The comparison is usually made on input items.

A model is prepared to study the performance of such algorithms which is called

decision tree. Hence any comparison-based sorting algorithms can be represented by a
decision tree. Each internal node of a binary decision tree represents a key comparison
indicated in the node, e.g., k < k.The node‘s left subtree contains the information about
subsequent comparisons made if k < k, and its right subtree does the same for the case
of k >k. Each leaf represents a possible outcome of the algorithm‘s run on some input of
size n. Note that the number of leaves can be greater than the number of outcomes
because, for some algorithms, the same outcome can be arrived at through a different
chain of comparisons. Number of leaves must be at least as large as the number of
possible outcomes. The algorithm‘s work on a particular input of size n can be traced by
a path from the root to a leaf in its decision tree, and the number of comparisons made
by the algorithm on such a run is equal to the length of this path.
Hence, the number of comparisons in the worst case is equal to the height of the
algorithm‘s decision tree.The central idea behind this model lies in the observation that
a tree with a given number of leaves, which is dictated by the number of possible
outcomes, has to be tall enough to have that many leaves. Specifically, it is not difficult
to prove that for any binary tree with l leaves and height h,
h ≥ [log2 l]. ---eqn 1
Indeed, a binary tree of height h with the largest number of leaves has all its leaves on
the last level. Hence, the largest number of leaves in such a tree is 2h.
In other words , 2h ≥ l, which immediately implies (eqn 1).
Fig.(a) Decision tree for finding a minimum of three numbers

Inequality eqn 1 puts a lower bound on the heights of binary decision trees and hence
the worst-case number of comparisons made by any comparison-based algorithm for
the problem in question. Such a bound is called the information theoretic lower bound .
We illustrate this technique below on two important problems: sorting and searching in a
sorted array.
Decision Trees for Sorting Algorithms

We can interpret an outcome of a sorting algorithm as finding a permutation of the
element indices of an input list that puts the list‘s elements in ascending order.
Consider, as an example, a three-element list a, b, c of orderable items such as real
numbers or strings. For the outcome a < c<b obtained by sorting this list (Figure b), the
permutation in question is 1, 3, 2. In general, the number of possible outcomes for
sorting an arbitrary n-element list is equal to n!.
Inequality above fig.(a) implies that the height of a binary decision tree for any
comparison-based sorting algorithm and hence the worst-case number of comparisons
made by such an algorithm cannot be less than [log2 n!]:
C worst (n) ≥ [log2 n!]
Using Stirling‘s formula for n!, we get
[ log n!] = ( log 1) + ( log 2) + …+ (log n)
[log2 n!] ≈ log2 √2πn(n/e)n
,= n log2 n − n log2 e +(log2 n/2)+(log2 2π/2)
≈ n log2 n.

Fig (b) Decision tree for the tree-element selection sort. A triple above a node
indicates the state of the array being sorted. Notes two redundant comparisons
b<a with a single possible outcome because of the results of some previously
made comparisons.
In other words, about n log2 n comparisons are necessary in the worst case to sort
an arbitrary n-element list by any comparison-based sorting algorithm. Note that merge
sort makes about this number of comparisons in its worst case and hence is
asymptotically optimal.
This also implies that the asymptotic lower bound n log2 n is tight and therefore cannot
be substantially improved. We should point out, however, that the lower bound of [log 2
n!] can be improved for some values of n.
Average-case efficiency can be
C avg (n) ≥ log2 n!. )
As we saw earlier, this lower bound is about n log2 n. You might be surprised that the
lower bounds for the average and worst cases are almost identical. Remember,
however, that these bounds are obtained by maximizing the number of comparisons
made in the average and worst cases, respectively. For a particular sorting algorithm,
the average-case efficiency can, of course, be significantly better than their worst-case
efficiency.
( C )Decision tree for the three-element insertion sort

Decision Trees for Searching a Sorted Array

In this section, we shall see how decision trees can be used for establishing lower
bounds on the number of key comparisons in searching a sorted array of n keys:
A[0]<A[1]< . . .<A[n − 1].
The principal algorithm for this problem is binary search. The number of comparisons
made by binary search in the worst case, C bs worst(n), is given by the formula
C bsworst(n) = _log2 n_ + 1= [log2(n + 1)]
leaves, i.e., as the average path length from the root to the leaves.
For example, for We will use decision trees to determine whether this is the smallest
possible number of comparisons.Since we are dealing here with three-way comparisons
in which search keyK is compared with some element A[i] to see whether K <A[i],K =
A[i], orK >A[i], it is natural to try using ternary decision trees. Figure (d) presents such a
tree for the case of n = 4.The internal nodes of that tree indicate the array‘s elements
being compared with the search key. The leaves indicate either a matching element in
the case of a successful search or a found interval that the search key belongs to in the
case of an unsuccessful search.
We can represent any algorithm for searching a sorted array by three-way comparisons
with a ternary decision tree similar to that in Figure 11.4. For an array of n elements, all
such decision trees will have 2n + 1 leaves (n for successful searches and n + 1 for
unsuccessful ones). Since the minimum height h of a ternary tree with l leaves is [log3 l],
we get the following lower bound on the number of worst-case comparisons:
Cworst(n) ≥ [log3(2n + 1]
This lower bound is smaller than [log2(n + 1)], the number of worst-case comparisons
for binary search, at least for large values of n (and smaller than or equal to [log2(n +
1)]for every positive integer n—see Problem 7 in this section‘s exercises). Can we prove
a better lower bound, or is binary search far from being optimal? The answer turns out
to be the former. To obtain a better lower bound, we should consider binary rather than
ternary decision trees, such as the one in Figure (e). Internal nodes in such a tree
correspond to the same three way comparisons as before, but they also serve as
terminal nodes for successful searches. Leaves therefore represent only unsuccessful
searches, and there are n + 1 of them for searching an n-element array

Fig (d) Ternary decision tree for binary search in a four-element array
As comparison of the decision trees in Figures (d) and (e) illustrates, the binary decision
tree is simply the ternary decision tree with all the middle subtrees eliminated. Applying
inequality fig (a) to such binary decision trees immediately yields
Cworst(n) ≥ [log2(n + 1)]. Total number of leaf nodes
Fig (e) Binary decision tree for binary search in a four-element array
This inequality closes the gap between the lower bound and the number of worstcase
comparisons made by binary search, which is also [log2(n + 1)]. A much more
sophisticated analysis shows that under the standard assumptions about searches,
binary search makes the smallest number of comparisons on the average, as well. The

average number of comparisons made by this algorithm turns out to be about log 2 n − 1
and log2(n + 1) for successful and unsuccessful searches, respectively.
3.Explain the P, NP, and NP Complete problems with suitable example[ CO4 –
L2 – Dec 2013]
Computational complexity
problems
P- class NP- class
NP- complete NP- hard
The problem in question is called the halting problem: given a computer program and an
input to it, determine whether the program will halt on that input or continue working
indefinitely on it.
Proof:Assume that A is an algorithm that solves the halting problem. That is, for any
program P and input I,
A(P, I ) = 1, if program P halts on input I ;

0, if program P does not halt on input I .
can consider program P as an input to itself and use the output of algorithm A for pair
(P, P) to construct a program Q as follows:
Q(P)= halts, if A(P, P) = 0, i.e., if program P does not halt on input P;

does not halt, if A(P, P) = 1, i.e., if program P halts input P.
Then on substituting Q for P, we obtain
Q(Q)= halts, if A(Q, Q) = 0, i.e., if program Q does not halt on input Q;

does not halt, if A(Q, Q) = 1, i.e., if program Q halts on input Q.

This is a contradiction because neither of the two outcomes for program Q ispossible,
which completes the proof.There are many important problems, however, for which no
polynomial-time algorithm has been found, Such problems are Hamiltonian circuit
problem.Determine whether a given graph has a Hamiltonian circuit—a path that starts
and ends at the same vertex and passes through all the other vertices exactly once.
Traveling salesman problem:Find the shortest tour through n cities with known positive
integer distances between them (find the shortest Hamiltonian circuit in a complete
graph with positive integer weights).
Knapsack problem:Find the most valuable subset of n items of given positive integer
weights and values that fit into a knapsack of a given positive integer capacity.
Partition problem:Given n positive integers, determine whether it is possible to partition

them into two disjoint subsets with the same sum.
Bin-packing problem:Given n items whose sizes are positive rational numbers not larger
than 1, put them into the smallest number of bins of size 1.
Graph-coloring problem:For a given graph, find its chromatic number, which is the
smallest number of colors that need to be assigned to the graph‘s vertices so that no
two adjacent vertices are assigned the same color.
Integer linear programming problem:Find the maximum (or minimum) value of a linear
function of several integer-valued variables subject to a finite set of constraints in the
form of linear equalities and inequalities.
Nondeterministic algorithm
A nondeterministic algorithm is a two-stage procedure that takes as its input an instance
I of a decision problem and does the following.
Nondeterministic (―guessing‖) stage: An arbitrary string S is generated that can be
thought of as a candidate solution to the given instance I (but may be complete
gibberish as well).
Deterministic:Deterministic (―verification‖) stage: A deterministic algorithm takes both I

and S as its input and outputs yes if S represents a solution to instance I. (If S is not a
solution to instance I, the algorithm either returns no or is allowed not to halt at all.)
A nondeterministic algorithm solves a decision problem if and only if for every yes
instance of the problem it returns yes on some execution.

Class of NP problems
Class NP is the class of decision problems that can be solved by nondeterministic
polynomial algorithms. This class of problems is called nondeterministic polynomialMost
decision problems are in NP. First of all, this class includes all the problems in P:
This is true because, if a problem is in P, we can use the deterministic polynomial

time algorithm that solves it in the verification-stage of a nondeterministic algorithm that
simply ignores string S generated in its nondeterministic (―guessing‖) stage.
NP also contains the Hamiltonian circuit problem, the partition problem, decision
versions of the traveling salesman, the knapsack, graph coloring, and many hundreds of
other difficult combinatorial optimization problems.
The halting problem, on the other hand, is among the rare examples of decision
problems that are known not to be in NP.
This leads to the most important open question of theoretical computer science: Is
P a proper subset of NP, or are these two classes, in fact, the same? We can put this
symbolically as
P = NP.
Note that P = NP would imply that each of many hundreds of difficult
combinatorial decision problems can be solved by a polynomial-time algorithm, although
computer scientists have failed to find such algorithms despite their persistent efforts
over many years. Moreover, many well-known decision problems are known to be ―NP-
complete‖ (see below), which seems to cast more doubts on the possibility that P =
NP.NP-Complete Problems
Informally, an NP-complete problem is a problem in NP that is as difficult as any
other problem in this class because, by definition, any other problem in NP can be
reduced to it in polynomial time (shown symbolically in Figure).
Most of the decision problems are NP complete problems

4. Explain elaborately recursive acktracking algorithm [ CO4 – L2 – Dec 2011/May

2013]
Introduction Backtracking and Branch and bound are two algorithm design techniques
for solving problems in which the number of choices grows atleast exponentially with
their instances size.Both techniques construct a solution one component at a time,
trying to terminate the process as soon as one can ascentain that no solution can be
obtained as a result of the choices already made.
This approach makes it possible to solve many large instances of NP hard problems in
an acceptable amount of time.The techniques branch and bound and backtracking are
base on the construction of a state space tree.A state space tree is a rooted tree whose
nodes represent partially constructed solutions to the problems.
Both techniques terminate a node as soon as it can be guaranteed that no solution to

the problem can be obtained by considering choices that correspond to the node‘s
descendants.
Difference between Branch and bound and Backtracking
The techniques differ in the nature of problems they can apply to. Branch and bound is
applicable only to optimization problems. Backtracking is applied to non optimization
problems.The other difference between backtracking and branch and bound lies in the
order in which nodes of the state space tree are generated.In backtracking technique,
the state space tree is developed using depth first which is similar to DFS.
In branch and bound the nodes of a state space tree is generated using best first rule.

Backtracking
Backtracking is a more intelligent variation of this approach.
The principal idea is to construct solutions one component at a time and evaluate such
partially constructed candidates as follows If a partially constructed solution can be
developed further without violating the problem‘s constraints, it is done by taking the first
remaining legitimate option for the next component. If there is no legitimate option for
the next component, no alternatives for any remaining component need to be
considered. In this case, the algorithm backtracks to replace the last component of the
partially constructed solution with its next option.
It is convenient to implement this kind of processing by constructing a tree of choices
being made, called the state-space tree.
Its root represents an initial state before the search for a solution begins.The nodes of
the first level in the tree represent the choices made for the first component of a
solution; the nodes of the second level represent the choices for the second component,
and so on.
Promising and nonpromising node
A node in a state-space tree is said to be promising if it corresponds to a partially

constructed solution that may still lead to a complete solution; otherwise,it is called
nonpromising. Leaves represent either nonpromising dead ends or complete solutions
found by the algorithm.A state space tree for a backtracking algorithm is constructed in
the manner of depth first search. If the current node is promising, its child is generated
by adding the first remaining legitimate option for the next component of a solution,
If the current node turns out to be nonpromising, the algorithm backtracks to the nodes
parent to consider the next possible option for its last component.If there is no such
option, it backtracks one more level up the tree, and so on. Finally, if the algorithm
reaches a complete solution to the problem, it either stops (if just one solution is
required) or continues searching for other possible solutions.Backtracking problems
require that all the solutions satisfy a complex set of constraints.
Two types of constraints are
(i) Explicit constraint
(ii) Implicit constraint
Backtracking technique is applied to
(i) N-Queens problem
(ii) Hamiltonian circuit problem
(iii) Subset sum problem

5.Explain N queen problemn-Queens Problem[ CO4 – H3 - May 2013]

The best problem to be solved using backtracking approach is the n-Queens problem.
The problem is to place n queens on an n × n chessboard so that no two queens attack
each other by being in the same row or in the same column or on the same diagonal.
For example –Consider 4 × 4 board
For n = 1, the problem has a trivial solution, and it is easy to see that there is no solution
for n = 2 and n = 3.
So let us consider the four-queens problem and solve it by the backtracking technique.
Since each of the four queens has to be placed in its own row, all we need to do is to
assign a column for each queen on the board presented in Figure
1 2 3 4
1  queen 1
2  queen 1
3  queen 1
4  queen 1
Chessboard for 4 Queens problem
Procedure Step 1:First start with the empty board.
1 2 3 4
1
2
3
4
Step 2:Then place queen 1 in the first possible position of its row, which is in column 1
of row 1.
1 2 3 4
1 Q
2
3
4
Step 3:Then we place queen 2, after trying unsuccessfully columns 1 and 2, in the first
acceptable position for it, which is square (2, 3), the square in row 2 and column 3.

1 2 3 4
1 Q
2 Q
3
4
Step 4:This proves to be a dead end because there is no acceptable position for queen
3. So, the algorithm backtracks and puts queen 2 in the next possible position at (2, 4).
1 2 3 4
1 Q
2 Q
3
4
Step 5:Now queen 3 is placed at position (3,2), which is acceptable position. Now the
chessboard is
1 2 3 4
1 Q
2 Q
3 Q
4
Step 6:Then queen 3 is placed at (3, 2), which proves to be another dead end. The
algorithm then backtracks all the way to queen 1 and moves the queen 1 from (1,1) to
(1, 2).
1 2 3 4
1 Q
2
3
4
Step 7:Queen 2 then goes to (2, 4)
1 2 3 4
1 Q
2 Q
3

Step 8:Now queen 3 is placed at the position (3, 1), which is acceptable position. Now
the board becomes
1 2 3 4
1 Q
2 Q
3 Q
4
Step 9:Finally the queen 4 to (4, 3), which is a solution to the problem, which is e
required solution to the problem. Now the board for four queens is
1 2 3 4
1 Q
2 Q
3 Q
4 Q
The state-space tree of this search is shown in Figure. If other solutions need to be
found (how many of them are there for the four queens problem?), the algorithm can
simply resume its operations at the leaf at which it stopped. Alternatively, we can use
the board‘s symmetry for this purpose.

Finally, it should be pointed out that a single solution to the n-queens problem for any n
≥ 4 can be found in linear time. In fact, over the last 150 years mathematicians have
discovered several alternative formulas for non attacking positions of n queens. Such
positions can also be found by applying some general algorithm design strategies.
6. Explain the procedure for tackling the 8 queens problem using

backtracking approach [ CO4 – L2 – Dec 2008/2011/May 2012/2013]
8 Queens problem
The is to successfully place 8 queens on a 8 × 8 chess board such that no two queens
attack each other. Two queens are said to be in the attack state if they are.
1. Placed in the same row
2. Placed in the same column
3. Placed along the same diagonal
Initially when 8 queens have to be placed on the (8 × 8) chess board,

si = { 1,2,3,4,5,6,7,8} ie. xi should have any of these positions.

1st queen position x1 can have any of these 8 values.
2nd queen position x2 can have any of these 8 values.
:
8th queen position x8 can have any of these 8 values.
The solution space will have 8 tuples. When these 8 8 tuples are bound by the implicit
conditions ( ie) the xi , s should be related such that they cannot have the same value
since no two queens are allowed to be placed on the same row or column , or along the
same diagonal, and hence the solution tuple can only be a permutation of s i { 1,2,…8}.
Hence the solution space reduces to 8! From 88
We have test whether two queens are on the same diagonal, it must satisfy the
following conditions.
• The chessboard squares being numbered as the indices of the two-
dimensional array a[1:8,1:8]
• Every element on the same diagonal that runs from the upper left to the
lower right has the same row-column value.

8-Queens problem
Explanation:
• Place(k, i) returns a Boolean value that is true if the kth queen can be placed
in column i. it tests both whether i is distinct from all previous values
x[1],…..x[k-1] and whether there is no other queen on the same diagonal.
• Its computing time is O(k-1)
All solutions to the n-queens problem:

Algorithm Place(k,i)
// This algorithm returns true if a queen can be placed in kth row and ith column.
Otherwise, it returns false.
// x[] is a global array whose first(k-1) values have been set.
// Abs(r) returns the absolute value of r.
{
for j = 1 to k-1 do
if ((x[j] = i) // Checks whether two Queens are in the same column
or (Abs(x[j] - i) = Abs(j - k))) // Checks whether they are in the same diagonal
then
return false;
return true;
}
Algorithm NQueens(k, n)
// Using backtracking, this procedure prints all
//possible placements of n queens on an n x n
// chessboard so that they are non attacking.
{
for i:=1 to n do
{
if Place(k, i) then
{
x[k]:=i;
if (k==n) then write (x[1:n]);
else NQueens(k+1, n);
}
}
}

(Fig) One solution to the 8-Queens problem

Solution Set:
The solution set contains the following value S = {4, 6, 8, 2, 7, 1, 3, 5}
The total number of nodes in the 8-queens state space tree is
7. Using backtracking enumerate how can you solve the following problem
Hamiltonian Circuit Problem [ CO4 – H3 – Dec 2008/2009/2010/2011/May 2014]
Definition
Given an undirected connected graph and two graph and two nodes x and y then find a
path from x to y visiting each node in the graph exactly once V1, V2…… Vn and the Vi
are distinct except for V1, and Vn+1, which are equal. The next example let us consider
the problem of finding a Hamiltonian circuit in the graph in Figure.
Without loss of generality, we can assume that if a Hamiltonian circuit exists, it starts at
vertex a. Accordingly, we make vertex a the root of the state-space tree .If solution exist
for a Hamiltonian circuit problem, the first component of our future solution, if it exists, is
a first intermediate vertex of a Hamiltonian circuit to be constructed.

Using the alphabet order to break the three-way tie among the vertices adjacent to a,
we select vertex b. From b, the algorithm proceeds to c, then to d, then to e, and finally
to f, which proves to be a dead end.So the algorithm backtracks from f to e, then to d,
and then to c, which provides the first alternative for the algorithm to pursue.Going from
c to e eventually proves useless, and the algorithm has to backtrack from e to c and
then to b. From there, it goes to the vertices f , e, c, and d, from which it can legitimately
return to a, yielding the Hamiltonian circuit a, b, f , e, c, d, a. Hence the solution is
obtained. If we wanted to find another Hamiltonian circuit, we could continue this
process by backtracking from the leaf of the solution found.
FIGURE (b) State-space tree for finding a Hamiltonian circuit. The numbers above the
nodes of the tree indicate the order in which the nodes are generated.
Example 2:Definition
Given an undirected connected graph and two graph and two nodes x and y then find a
path from x to y visiting each node in the graph exactly once
Then the Hamiltonian cycle A-B-D-E-C-F-A. this problem can be solved using
backtracking approach. The state space tree is generated in order to find all the
Hamiltonian cycle in the graph.
Only distinct cycles are output of this algorithm. The Hamiltonian cycle can be identified
as follows fig (b).

fig (b) clearly the backtrack approach is adopted. For instance A-B –D- F- C- E; here we
get stuck. For returning to A we have to revisit atleast one vertex. Hence we
backtracked and from D node another path is chosen A- B- D- E-C-F-A which is
Hamiltonian cycle.
A B
D
C
E
Fig (a) Graph G

Fig(b): finding Hamiltonian cycle

ALGORITHM AND ANALYSIS
Algorithm Hamiltonian (k)
// This algorithm finds all the Hamiltonian cycle of a graph.
// The graph is stored as an adjacency matrix G[1..n, 1..n]
// All cycles begin at node 1
{
repeat
{
//Generate values for x[k]
NextValue(k); //Assign a legal next value to x[k]
if(x[k] = 0) then
return;
if (k = n) then
print x[1..n];

else
Hamiltonian(k+1);
} until(false);
}
Algorithm NextValue(k)
// This algorithm generates a next vertex
// x[1..k-1] is a path of k-1 distinct vertices
// if x[k]=0, then no vertex has as yet been assigned to x[k].
// After execution, x[k] is assigned to the next highest numbered vertex which
does not already appear in x[1..k-1] and is connected by an edge to x[k-1]
// Otherwise x[k]=0. If k=n, then in addition x[k] is connected to x[1]
{
repeat
{
x[k] = (x[k] + 1) mod (n + 1); //next vertex
if(x[k]=0) then
return;
if(G[x[k-1], x[k]]  0) then
{
//is there an edge?
for j =1 to k-1 do
if(x[j] = x[k]) then
break;
//check for distinctness
if(j = k) then //if true, then the vertex is distinct
if((k < n) or ((k = n) and G[x[n], x[1]  0))
then return;
}
}until(false)
}
The algorithm is started by first initializing the adjacency matrix G[1..n.1..n], setting
x[2..n] to zero and x[1] to 1 and then executing Hamiltonian(2).

8.Explain Subset-Sum Problemand discuss the possible solution strategies

using backtracking[ CO4 – L2 - May/June 2012]
The subset sum problem is used to find a subset of a given set.
A = {a1, . . . , an} of n positive integers whose sum is equal to a given positive integer d.
It always convenient to sort the sets elements in ascending order. That is,
A1 ≤ A2 ≤ ….≤An
Let us first write a general algorithm for sum of subset problem
Algorithm:
Let , S be a set of elements and d is the expected sum of subset. Then
Step 1: start with an empty set
Step 2: add to the subset, the next element from the list
Step 3: if the subset is having sum d then stop with the subset as solution.
Step 4: if the subset is not feasible or if we have reached the end of the set then
Backtrack through the subset until we find the most suitable value.
Step 5: if the subset is feasible then repeat step 2
Step 6: if we have visited all the elements without finding a suitable subset and if no
backtracking is possible then stop without solution.
For example 1, for A = {1, 2, 5, 6, 8} and d = 9, there are two solutions: They are,
Solution :
Initially subset = {} Sum = 0
Now add the next
1 1 element
1, 2 3 therefore 3<9 Add next the element

1,2,5 8 therefore 8<9 Add next the element
1,2,5,6 14 Sum exceeds the
given constraint hence
backtrack
backtrack
1,2,6 9=9 Solution is found
1,8 9=9 Solution is found
1. {1, 2, 6} is a first subset
2. {1, 8}is a second subset

3. Before finding the subset of a given set, the set‘s elements are sorted in
increasing order. So, we will assume that
a1≤a2 ≤ . . . ≤ an.
For subset sun problem, the state space tree is constructed as a binary tree
which is shown in the figure below.
ALGORITHM AND ANALYSIS

Algorithm SumOfSub(s,k,r)
// This algorithm finds all subsets of w[1..n] that sum to d
// The values of x[j], 1 j< k, have already been determined.
k 1 n
// s =  w[ j ] * x[ j ] and r =  w[ j ]
j 1 j k
// The w[j]‘s are in non-decreasing order.

n
//It is assumed that w[1]  d and  w[i]  d
i 1

{
// Generate left child.
x[k] =1; The subset is printed
if (s + w[k] = d) then
print x[1..k] // subset found
// There is no recursive call here as w[j] > 0, 1  j  n.
else if(s + w[k] +w[k+1]  d)
then SumOfSub(s + w[k], k+1, r-w[k]); Search the next element
//Generate right child which can make sum ≤ d
if (( s + r – w[k]  d ) and ( s + w[k+1]]  d)) then
{
x[k] = 0;
SumOfSub( s, k+1, r–w[k] );
}
}
n
The initial call to the algorithm is SumOf Sub(0,1,  w i ).
in
Example 2:
A = {3, 5, 6, 7} and d = 15
A = {3, 5, 6, 7} and d = 15
The state-space tree can be constructed as a binary tree like that in Figure for
the instance A = {3, 5, 6, 7} and d = 15.
The root of the tree represents the starting point, with no decisions about the
given elements made as yet.
 Its left and right children represent, respectively, inclusion and exclusion of a1 in
a set being sought. Similarly, going to the left from a node of the first level
corresponds to inclusion of a2 while going to the right corresponds to its
exclusion, and so on.
Thus, a path from the root to a node on the ith level of the tree indicates which of
the first i numbers have been included in the subsets represented by that node. We
record the value of s, the sum of these numbers, in the node.

 If s is equal to d, we have a solution to the problem.We can either report this

result and stop or, if all the solutions need to be found, continue by backtracking
to the node‘s parent.
 If s is not equal to d, we can terminate the node as nonpromising if either of the
following two inequalities holds:
s + ai+1> d (the sum s is too large),
s+∑ < d (the sum s is too small).\

Solution :
Now add the next
3 3 element
3,5 8 therefore 8 <15 Add next the element

3,5,6 14 therefore 14 < 15 Add next the element
backtrack

FIGURE Complete state-space tree of the backtracking algorithm applied to the

instance A = {3, 5, 6, 7} and d = 15 of the subset-sum problem.
The number inside a node is the sum of the elements already included in the
subsets represented by the node.
9. Draw the tree representation to solve the subset sum problem given the
numbers set as A = {3, 5, 6, 7 , 2} and with sum = 15 Derive all the subsets.
[ CO4 – H3 – Nov/Dec 2010]
Solution:
The inequality below a leaf indicates the reason for its termination.
A = {3, 5, 6, 7 , 2} and sum = 15
The state-space tree can be constructed as a binary tree like that in Figure for the
instance A = {3, 5, 6, 7 , 2} and sum = 15.

Now add the next
3 3 element


backtrack
3,5,6,7,2 23 Sum exceeds the
backtrack
6,7,2 15 = 15 Solution is found
backtrack
State Space Tree

Example 4.
Let, w = { 5,7,10,12,15,18,20} and m = 35. Find all possible subset of w whose sum
is equivalent to m. draw the portion of state space tree for this problem. Au : Dec
– 12
Solution:

5 Now add the next
5 element

5,7,10,12 34 therefore 34 < 35 Add next the element
5,7,10,12,15 49 Sum exceeds the
backtrack
5,7,10,12,18 52 therefore 52< 35 Sum exceeds the
backtrack
5,7,10,12,20 54 therefore 54> 35 Sum exceeds the
backtrack
5,7,10,15 37therefore 37> 35 Sum exceeds the
backtrack
backtrack
backtrack
5,7,12 24therefore 24< 35 Add next the element


backtrack
backtrack
backtrack
15,20 35=35 Solution is found
The portion of state space tree is as follows

10.Explain the Assignment Problem by the branch and bound algorithm with an
example[ CO4 – L2 - May/June 2015]
The branch-and-bound approach by applying it to the problem of assigning n people to
n jobs so that the total cost of the assignment is as small as possible.
An instance of the assignment problem is specified by an n × n cost matrix C so that we
can state the problem as follows:
select one element in each row of the matrix so that no two selected elements are in the
same column and their sum is the smallest possible.

We will demonstrate how this problem can be solved using the branch-and-bound
technique by considering the same small instance of the problem A small instance of
this problem with the table‘s entries representing the assignment C[i,j].
Job 1 Job 2 Job 3 Job 4

Person a 9 2 7 8
Person b 6 4 3 7
Personc 5 8 1 8
Person d 7 6 9 4
If we select minimum value from each row then we get,

Person 9 2 7 8
a
Person 6 4 3 7 =>2+3 + 1+ 4 = 10
b Hence set lower bound = 10
Person 5 8 1 8 Now the state space tree can be drawn
c step by step
Person 7 6 9 4
d
Start
Lower = 2 +3+1+4
Bound (lB)=10
a-> 1
LB = 9+3+1+4 =17
select as a = 1 st element (1) person a

9 2 7 8

6 4 3 7
5 8 1 8
7 6 9 4
Select minimum values from remaining

rows (3)
Do not select any number from this column (1 &2)
Start
Lower = 2 +3+1+4
Bound (lB)=10
a-> 2
LB = 2 +3+1+4=10
select as a = 2 nd element (1) person a

9 2 7 8
6 4 3 7 Select minimum values from remaining
5 8 1 8 rows (3)
7 6 9 4
Do not select any number from this column (2)

Start
Lower = 2 +3+1+4
Bound (lB)=10

a-> 3
LB = 7 +4+5+4=20
Select as a = 3 rd element (1) person a

9 2 7 8
6 4 3 7 We cannot choose 3 and 1 therefore they
5 8 1 8 are under same column . Hence next smaller
7 6 9 4 value is selected values from remaining
rows (3)
Start
Lower = 2 +3+1+4
Bound (lB)=10
a-> 4
LB = 8+3+1+6=18
Select as a = 4 th element (1) person a

9 2 7 8
6 4 3 7
5 8 1 8 Select minimum values from remaining
7 6 9 4 rows (3)

Thus we have set jobs for person a , then we select jobs for person b then for person c
and finally for person d.

Start
LB = 10
a->1 a->2 a->4

LB = 17 a->3 LB = 18
LB = 10
LB = 20
This is a promising node and it is

b->1 b->3
b->4
LB = 17 LB = 17
LB = 17 Expanded
9 2 7 8
9 2 7 8
6 4 3 7
6 4 3 7
5 8 8
1 5 8 8
7 6 9 1
4 Minimum select 6 9 4
7
from reaming rows
Do not select remaining
9 2 7 8 elements from these columns of c
6 4 3 7 and d
8 1 8
5
Do not select remaining 7 6 9
elements from these columns 4
Do not select remaining
elements from these columns
fig :Levels 0, 1, and 2 of the state-space tree for the instance of the
assignmentProblem being solved with the best-first branch-and-bound algorithm
it is a solution because

i). We have got minimum values from each columns

ii). No values selected is under same column
Thus assignment problem can be solved with best fit branch and bound algorithm
let us understand some commonly used terminologies in branch and bound.
Live node – it is a node in state space tree which is a promising node and it can be
further expanded in order to get the solution to given problem.
For example
Fig : node 2 live node
Best first branch and bound

This is a searching strategy which is adopted in order to find optimal solution from a
state space tree by means of expanding promising node

Fig Complete state-space tree for the instance of the assignment problem solved
with the best-first branch-and-bound algorithm.
11.Solve the following instance of the knapsack problem by the branch and
bound[ CO4 – H3 – Nov/Dec 2006/2008/2010]
Knapsack Problem
The branch-and-bound technique is used to solving the knapsack problem.The
Knapsack problem is given n items of known weights wi and values vi , i = 1, 2, . . . , n,
and a knapsack of capacity W, find the most valuable subset of the items that fit in the
knapsack.It is convenient to order the items of a given instance in descending order by
their value-to-weight ratios.Then the first item gives the best payoff per weight unit and
the last one gives the worst payoff per weight unit, with ties resolved arbitrarily:
v1/w1 ≥ v2/w2 ≥ . . . ≥ vn/wn.
Each node on the ith level of this tree, 0 ≤ i ≤ n, represents all the subsets of n items that
include a particular selection made from the first i ordered items.This particular selection
is uniquely determined by the path from the root to the node.
A branch going to the left indicates the inclusion of the next item
A branch going to the right indicates its exclusion.
We record the total weight w and the total value v of this selection in the node, along
with some upper bound ub on the value of any subset that can be obtained by adding
zero or more items to this selection. A simple way to compute the upper bound ub is to
add to v, the total value of the items already selected, the product of the remaining
capacity of the knapsack W − w and the best per unit payoff among the remaining
items, which is vi+1/wi+1:

ub = v + (W − w)(vi+1/wi+1)
Construction of a State space Tree

It is natural to structure the state-space tree for this problem as a binary tree
constructed as follows, which is shown in figure.
Item Weight Value Value/Weight
1 4 $40 10
W= capacity of Knapsack‟s = w =10.
2 7 $42 6
3 5 $25 5
4 3 $12 4
We will first compute the upper bond by using above given formula
ub = v + (W − w)(vi+1/wi+1)
Initially v=0 , w=0 and vi +1 = v1 = 40 and w i+1 = wi+1 = w1 = 4. The capacity W = 10
Ub = 0 +(10-0)(40/4)
= (10) (10)
Ub = 100$
Now we will construct a state space tree by selecting different items
Computation at node 0
i,e . root of state space tree
Initially v=0 , w=0 and vi +1 = v1 = 40 and w i+1 = wi+1 = w1 = 4. The capacity W = 10
Ub = 0 +(10-0)(40/4)
= (10) (10)
Ub = 100$
Computation at node I
At node I in state space tree we assume the selection of item 1.
Therefore v= 40 , w = 4
The capacity W = 10
Now vi +1/ w i+1 -> means next item to item 1
i.e v2/w2 = 6
ub = v + (W − w)(vi+1/wi+
= 40 +(10-4)*

= 40 + 6 *6
ub =76
Computation at node II
At node II in state space tree we assume the selection of item 1. Not selected
The capacity W = 10
Next to item 1 is item 2
Now vi +1/ w i+1 -> means 2
i.e v2/w2 = 6
ub = v + (W − w)(vi+1/wi+1)
= 0 +(10-0)*6
= 40 + 6 *6
ub =60
Computation at node III

At this node we pick up item 1 and item 2 but the weight becomes 4+7 = 11. This
exceed the capacity of knapsack. Hence we will not consider this node
Computation at node IV
At node item 2 is not selected and only item 1 is selected.
The capacity W = 10
Next item will be item 3 selected
Now vi +1/ w i+1 = v3/w3 = 20/5=5
ub = v + (W − w)(vi+1/wi+1)
= 40 +(10-4)*5
= 40 + 6 *5
ub =70
Computation at node V
Node VI is an instance at which only item 1 and item 3 are selected . and item 2 is not
selected
vi +1/ w i+1 = v3/w3 = 25/5 =5
v = 40 + 25 = 65
w = 4 +5 = 9

The capacity W = 10
The next item would be vi +1/ w i+1 -> item 4
Therefore v4/w4 = 12/3 =4
ub = v + (W − w)(vi+1/wi+1)
= 65 +(10-9)*4
= 65 + 1 *4 ub =69
Computation at node VI
At node VI is an instant at which item 1 is selected , item 2 and item 3 are not selected .
The capacity W = 10
The Next item being selected is item 4
Now vi +1/ w i+1 = v4/w4= 12/3 =4
i.e v4/w4 = 4
ub = v + (W − w)(vi+1/wi+
=4 0 +(10-4)*4
= 40 + 6 *4 ub =64
Computation at node VII

At node VII , we consider selection of item 1, item 3, item 4. There is no next item given
problem statement
vi +1/ w i+1=0
w = 4 + 5+ 3 = 12 -> but this is exceeding capacity W = 10
v = 40 + 25 + 12 = 72
W = 10
ub = v + (W − w)(vi+1/wi+1)= 72 + (10 -12)* 0 ub = 72
But as weight of selected items exceed the capacity W this is not a feasible solution.
Computation at node VIII

At node VIII , we consider selection of item 1and item 3.There is no next item given
problem statement
vi +1/ w i+1=0
w = 4 + 5= 9 -> but this is exceeding capacity W = 10
v = 40 + 25 = 65

W = 10
ub = v + (W − w)(vi+1/wi+1)= 65 + (10 -9)* 0 ub = 65
The node IX is a node indicating maximum profit of selected items with maximum
weight of item = 9 i.e . <capacity of knapsack ( W=10)
Thus solution is pick up { item 1, item3 } and gain maximum profit 65$
Fig :State-space tree of the best-first branch-and-bound algorithm for the

instance of the knapsack problem.

Design and Analysis of Algorithm

Uploaded by

Copyright:

Available Formats

Design and Analysis of Algorithm

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Design and Analysis of Algorithm

Uploaded by

Copyright:

Available Formats

S.K.P.

Engineering College, Tiruvannamalai IV SEM

SKP Engineering College

Computer Science Engineering Department 1 Design and Analysis of Algorithm

This is to Certify that the Electronic Study Material

Subject Code: CS6402

Subject Name: Design and Analysis of Algorithms

Being prepared by me and it meets the knowledge requirement of the University

Signature of the Author

Designation: Assistant Professor

Signature of HD Signature of the Principal

Name: K.Baskar Name: Dr.V.Subramania Bharathi

Computer Science Engineering Department 2 Design and Analysis of Algorithm

CS6402 DESIGN AND ANALYSIS OF ALGORITHMS LTPC3003

UNIT II BRUTE FORCE AND DIVIDE-ANCONQUER 9

UNIT III DYNAMIC PROGRAMMING AND GREEDY TECHNIQUE 9

UNITIV ITERATIVIE IMPROVEMENT 9

UNIT V COPING WITH THE LIMITATIONS OF ALGORITHM POWER 9

Computer Science Engineering Department 3 Design and Analysis of Algorithm

Computer Science Engineering Department 4 Design and Analysis of Algorithm

S.No Particulars Page

Computer Science Engineering Department 5 Design and Analysis of Algorithm

Computer Science Engineering Department 6 Design and Analysis of Algorithm

1. Define an algorithm.[ CO1 - L1 - Nov/Dec 2014]

2. Define Program. [ CO1 - L1 - May/June 2012]

3. What is performance measurement? [ CO1 - L1 - May/June 2013]

Computer Science Engineering Department 7 Design and Analysis of Algorithm

6. What is space complexity? [ CO1 - L1 - Nov/Dec 2010]

7. What is time complexity? [ CO1 - L1 - Nov/Dec 2010]

8. Give the two major phases of performance evaluation. [ CO1 - L1]

9. Define input size. [ CO1 - L1]

10. Define best-case step count. [ CO1 - L1 - May/June 2010]

11. Define worst-case step count. [ CO1 - L1 - Nov/Dec 2010]

12. Define average step count. [ CO1 - L1]

t(n) ≤ c*g(n) for all n ≥ n0.

Computer Science Engineering Department 8 Design and Analysis of Algorithm

14. Define the asymptotic notation “Omega” ( Ω ). [ CO1 - L1 - Nov/Dec 2010]

Computer Science Engineering Department 9 Design and Analysis of Algorithm

16. What is a Computer Algorithm? [ CO1 - L1]

17. What are the features of an algorithm? [ CO1 - L1 - May/June 2013]

18. Discuss notion of an algorithm. [ CO1 – L2 – Dec 2009 / May 2013]

Computer Science Engineering Department 10 Design and Analysis of Algorithm

19. Classify different problem types? [ CO1 – L3 - Nov/Dec 2013]

20. What are different algorithm design techniques/strategies?

21. How the running time of an algorithm is measured?

22. How time efficiency is analyzed? [ CO1 – H1 - Apr/May 2015]

Computer Science Engineering Department 11 Design and Analysis of Algorithm

23. What are orders of growth? [ CO1 – L1 - Apr/May 2015]

24. What are basic efficiency classes? [ CO1 - L1 - Apr/May 2012]

25. Give an example for basic operations. [ CO1 - L1 - May/June 2012]

Multiplication of two Matrix dimensions or

Checking primality of a size = number of digits Division

Number of vertices Visiting a vertex

Computer Science Engineering Department 12 Design and Analysis of Algorithm

26. What are steps processes in algorithmic problem solving?

27. What do you mean by Amortized Analysis? [ CO1 - L1 - Nov/Dec 2012]

28. Define order of an algorithm. [ CO1 - L1 - Nov/Dec 2014]

Computer Science Engineering Department 13 Design and Analysis of Algorithm

31.Write doun the properties of asymptotic notations.[CO1 - L1 – Apr/May 2015]