DAA- MC9223 notes

Attribution Non-Commercial (BY-NC)

43 views

DAA-unit I

DAA- MC9223 notes

Attribution Non-Commercial (BY-NC)

- 258 Data Structures Interview Questions and Answers
- CS8251-Programming in C Notes
- Introduction to Algorithms, Second Edition ( PDFDrive.com ).pdf
- New Syllabus
- lec37-nov03
- 1.1 Basic Data Structure (2)
- daa prev final.docx
- Ge8161-Pspp Lab Manual
- Big O Notation
- SA Implementations
- Google Guide
- Billion-scale Similarity Search With GPUs
- big_o
- CS372_Syllabus
- Big O Algorithm Complexity Cheat Sheet
- algorithm = logic + control.pdf
- Slides Algo-Inversions2 Typed
- coding questions.docx
- ptoticAnalysis
- sortingalgorithms-1232354736607028-2

You are on page 1of 35

Fundamentals of algorithmic problem solving Important problem types Fundamentals of the analysis of algorithm efficiency analysis frame work Asymptotic notations Mathematical analysis for recursive and non-recursive algorithms.

Definition of Algorithm:

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.

There are various steps to be involved in the algorithm design and analysis processes are: 1. 2. 3. 4. 5. 6. 7. 8. 9. Understanding the Problem Ascertaining the Capabilities of the Computational Device Choosing between Exact and Approximate Problem Solving Algorithm Design Techniques Designing an Algorithm and Data Structures Methods of Specifying an Algorithm Proving an Algorithms Correctness Analyzing an Algorithm Coding an Algorithm

Introduction

Decide on: computational means, exact vs. approximate solving, algorithm design technique

Design an algorithm

Prove correctness

Understanding the Problem: To designing an algorithm understand the given problem completely by reading the problems description carefully. If the user have any doubts about the problem statement then ask questions to clarify the doubts. To do few small examples and then think about special cases, if required again ask questions by the user. If the problem in question is one of them, the user might be able to use a known algorithm for solving it. It help us to understand how an algorithm will works and to know its strengths and weaknesses of particular algorithm. Especially, if the user have to choose among any one several available algorithms. But the user will not find a readily available algorithm and design it own. An input to an algorithm specifies an instance of the problem. Once the problem is clearly understand, then determine the overall goals, but it should be in a clear manner. Then divide the problems into smaller problems until they become manageable size.

Introduction

Ascertaining the Capabilities of the Computational Device: Once the user completely understand a problem, they need to ascertain the capabilities of the computational device the algorithm is intended for. Random-access machine (RAM): Its central assumption is that instructions are executed one after another, one operation at a time. Sequential algorithms: Algorithms designed to be executed on such machines are called sequential algorithms. Parallel algorithms: The central assumption of the RAM model does not hold for some newer computers that can execute operations concurrently, i.e., in parallel. Algorithms that take advantage of this capability are called parallel algorithms. Choosing between Exact and Approximate Problem Solving: The next principal decision is to choose between solving the problem exactly or solving it approximately. In the former case, an algorithm is called an exact algorithm; in the latter case, an algorithm is called an approximation algorithm. Exact algorithm: The algorithm is used to solve exactly is called exact algorithm. Approximate algorithm: The algorithm is used to solve approximately is called approximate algorithm. Benefits to choose approximate algorithm: 1. There are important problems that cannot be solved exactly, such as: Extracting square roots, Solving nonlinear equations, and Evaluating definite integrals. 2. The algorithms are available for solving a problem exactly can be unacceptably slow because of the problems intrinsic complexity. The most well known of them are travelling sales man problem of finding shortest path through n cities. 3. An approximation algorithm can be a part of a more sophisticated algorithm that solves a problem exactly.

Introduction

Algorithm Design Techniques: Definition:

An algorithm design technique (or strategy or paradigm) is a general approach to solving problems algorithmically that is applicable to a variety of problems from different areas of computing. The following reasons are the utmost importance of algorithm of algorithm design technique. 1. They provide guidance for designing algorithms for new problems, i.e., problems for which there is no known satisfactory algorithm. 2. algorithms are the cornerstone of computer science. This techniques make it possible to classify algorithms based on the design idea. They can serve as a natural way to both categorize and study algorithms. Designing an Algorithm and Data Structures: Data structure can be defined as a particular scheme of organizing related data items.

Some algorithms do not demand any ingenuity is representing their inputs. Some of the algorithm design techniques depend intimately on structuring or restructuring data specifying a problems instance. The variability is an algorithm is due to, in which data of the program are stored. In OOPs, data structures is crucially important for both design and analysis of algorithms.

Methods of Specifying an Algorithm: These are the two options that are most widely used nowadays for specifying algorithms. They are: Euclids algorithm: Euclids algorithm is specified by simple English statement and it is step-by-step form. Pseudocode: Pseudocode is a mixture of constructs a natural language and programming language. It is usually more precise than natural language.

4

Introduction

For the sake of simplicity, we omit declarations of variables and use indentation to show the scope of such statements as for, if, and while statement. An arrow is used for the assignment operation and two slashes // is used for comments. A flowchart, a method of expressing an algorithm by a collection of connected geometric shapes containing descriptions of the algorithms steps.

Proving an Algorithms Correctness: Once an algorithm has been specified, you have to prove its correctness. The user have to prove that the algorithm yields a required result for every legitimateinput in a finite amount of time. For example, the correctness of Euclids algorithm for computing the greatest common divisor stems from the correctness of the equality gcd(m, n) = gcd(n, m mod n. Correctness: Prove that the algorithm Yields the required result for every legitimate input in a finite amount of time. A common technique for proving correctness is to use mathematical induction In order to show the algorithm is incorrect, we have to take just one instance of its input for which the algorithm fails. If a algorithm is found to be incorrect, then reconsider one or more those decisions For approximation algorithms we should show that the error produced by the algorithm does not exceed the predefined limit. The notion of correctness for approximation algorithms is less straightforward than it is for exact algorithms. For an approximation algorithm, we usually would like to be able to show that the error produced by the algorithm does not exceed a predefined limit.

Analyzing an Algorithm: Efficiency of an algorithm can be measured in terms of space and time. Time efficiency: It indicates how fast the algorithm runs, the amount of time needed for executing an algorithm. Space efficiency: It indicates how much extra memory it uses.

Introduction

Characteristic of an algorithm: There are three characteristics of efficiency of an algorithm. They are: Simplicity Generality Optimality Simplicity: Simple algorithms mean easy to understand and easy to program. Generality: Design an algorithm for a problem in more general terms. In some cases, designing more general algorithm is unnecessary or difficult. Optimality: The algorithm should produce optimal results.

Complexity of an algorithm: Complexity of an algorithm is measured by calculating the time taken and space required for performing the algorithm. Time Complexity: Time complexity of an algorithm is the amount of time needed by an algorithm to complete its task. The way in which the number of steps required by an algorithm varies with the size of the problem. The time taken for an algorithm is comprised of 2 types. They are: Compilation time Run time Compilation time: Compilation is the time taken to compile an algorithm. It checks the syntax and semantic errors in the program. It takes own time to compile. Compilation time is always depending upon the compiler, since different compilers can take different time to compile the same program. Run time: Run time is the time to execute to execute the compiled program. It calculated only for executable statements and not for declaration statements. Time complexity can be classified into 3 types. They are: Worst case Average case Best case

6

Introduction

Worst case:

The algorithm runs the longest among all possible inputs of size n. This can be represented by a function. f(n) = n2 (or) f(n)= n log n The user can write as T(n) = O(f(n)) The algorithm will not take more than f(n) operations. Best case: The algorithm runs the fastest among all possible inputs of size n. The user can write as T(n) = (f(n)) Average case: It is the average time that the algorithm will use over all instances of size n for given problem. It depends upon the probability distribution of instance of the algorithm. Space Complexity: Space complexity of a program is the amount of memory consumed by the algorithm until it completes its execution. The way in which the amount of storage space required by an algorithm varies with the size of the problem to be solved.

Coding an Algorithm: Algorithms are designed to be implemented as computer programs. Programming an algorithm presents both a peril and an opportunity. The peril lies in the possibility of making the transition from an algorithm to a program either incorrectly or very inefficiently. The user validity of programs by testing. Whenever user implements an algorithm test and debugs the program thoroughly. When implementing algorithms as programs to be used in actual applications, the user should provide such verifications. Use code tuning technique. For eg., replacing costlier multiplication operation with cheaper addition operation. Implementing an algorithm correctly is necessary but not sufficient.

7

One encounters in computing, there are a few areas that have attracted particular attention from researchers. Interest has been driven either by the problems practical importance or by some specific characteristics making the problem an interesting research subject. Fortunately, these two motivating forces reinforce each other in most cases. The most important problem types are, Sorting Searching String processing Graph problems Combinatorial problems Geometric problems Numerical problems

Sorting: The sorting problem is to rearrange the items of a given list in ascending order. Input: A sequence of n numbers <a1, a2, , an> Output: A reordering <a1, a2, , an> of the input sequence such that a 1 a 2

.. a n.

The user usually need to sort lists of numbers, characters from an alphabet, character strings, and, most important, records similar to those maintained by schools about their students, libraries about their holdings, and companies about their employees. In the case of records, the user needs to choose a piece of information to guide sorting. Sorting key: A specially chosen piece of information used to guide sorting is called a key. i.e., sort student records by names. The user can choose to sort student records in alphabetical order of names or by student number or by student grade-point average. There are a few good sorting algorithms that sort an arbitrary array of size n using about n log2 n comparisons.

Internal Sorting: It is used to sort small amount of data i.e. less than 100. Unsorted datas are stored in main memory. So first fetch the unsorted datas from main memory and apply any one of the internal sorting techniques. Finally store the sorted datas in main memory itself.

8

Introduction

Examples:

Bubble sort, Selection sort, Insertion sort, Heap sort, Quick sort.

External Sorting: It is used to sort large quantity of data i.e. Greater than 100.Unsorted datas are stored in Secondary storage devices. Fetch unsorted datas from secondary storage devices into main memory and apply any one of the external sorting techniques. Then store the sorted datas in Secondary storage devices. Example: Merge sort, poly phase merge. Properties of Sorting: Stability: A sorting algorithm is called stable if it preserves the relative order of any two equal elements in its input. If an input list contains two equal elements in positions i and j where i < j, then in the sorted list they have to be in positions i and j, respectively, such that i < j. The second notable feature of a sorting algorithm is the amount of extra memory the algorithm requires.

In place:

A sorting algorithm is in place if it does not require extra memory, except, possibly for a few memory units. Searching: The searching problem deals with finding a given value, called a search key, in a given set of elements. There are several searching algorithms for searching. They range from the straightforward sequential search to a spectacularly efficient but limited binary search and algorithms based on representing the underlying set in a different form more conducive to searching. The latter algorithms are of particular importance for real-life applications because they are indispensable for storing and retrieving information from large databases. Example: Sequential searching Binary searching

9

Introduction

String Processing:

A string is a sequence of characters from an alphabet. Text string Bit String Text strings contains letters, numbers, and special characters. Bit string contains 0s and 1s. String matching indicates searching for a given word/pattern in a text. Gene sequences which can be modeled by strings of characters from the four-character alphabet {A, C, G, T}.

Graph Problems: Most interesting areas in algorithmics is graph algorithms. A graph is a collection of points called vertices and connected line segments are called edges. G={V,E} V denotes vertices E denotes edges

Graphs are an interesting to study, for both theoretical and practical reasons. Graphs can be used for modeling a wide variety of applications, including transportation, communication, social and economic networks, project scheduling, and games. Various graph algorithm: Graph Traversal: It is the process of determining the possible way for visiting the nodes of graph. They are: Depth First Search Breadth First search Shortest path algorithm: It is used to find the shortest distance between source nodes to all other nodes in the graph. Topological sorting: Topological sorting is an ordering of vertices in a directed acyclic graph. Such that if there is path from Vi and Vj appears after Vi in the ordering.

10

Introduction

Traveling salesman problem (TSP): The problem of finding the shortest tour through n cities that visits every city exactly once. In addition to obvious applications involving route planning, it arises in such modern applications as circuit board and VLSI chip fabrication, X-ray crystallography, and genetic engineering. Graph-coloring problem: It ask us to assign the smallest number of colors to the vertices of a graph so that no two adjacent vertices are the same color. Combinational problem: The traveling salesman problem and the graphcoloring problem are examples of combinatorial problems. These are problems that ask, explicitly or implicitly, to find a combinatorial object such as a permutation, a combination, or a subsetthat satisfies certain constraints. Combinatorial problems are the most difficult problems in computing, from both a theoretical and practical standpoint. Their difficulty stems from the following facts. 1. The number of combinatorial objects typically grows extremely fast with a problems size, reaching unimaginable magnitudes even for moderate-sized instances. 2. There are no known algorithms for solving most such problems exactly in an acceptable amount of time. Geometric Problems: It deals with geometric objects such as points, lines and polygons. The ancient Greeks were very much interested in developing procedures for solving a variety of geometric problems, including problems of constructing simple geometric shapestriangles, circles, and so on. Two classic geometric problems: Closest Pair Problem: Given n points in the plain, find the closest pair among them. Convex hull problem: It finds the smallest convex polygon that would include all points of a given set If the user are interested in other geometric algorithms, the user will find a wealth of material in such specialized monographs. ORo98

11

Introduction

Numerical Problems: Problems that involve mathematical objects of continuous nature. Eg.: Solving equations and system of equations, computing definite integrals evaluating functions, etc., Most numerical problems are solved approximately Difficulties in numerical problems: Real numbers are represented approximately. Hence round off error will occur. A large number of arithmetic operations performed on approximately represented numbers can lead to an accumulation of the round-off error to a point where it can drastically distort an output produced by a seemingly sound algorithm

Analysis Framework:

The framework for analyzing the efficiency of algorithms. There are two kinds of efficiency: Time efficiency, and Space efficiency. Time efficiency: It indicates how fast an algorithm in question runs and also called as time complexity. Space efficiency: It refers to the amount of memory units required by the algorithm in addition to the space needed for its input and output. SYNOPSIS: Measuring an inputs size Measuring running time Orders of growth (of the algorithms efficiency function) Worst-base, best-case and average efficiency Recapitulation of the analysis framework Measuring an Input size: Lets start with the obvious observation that almost all algorithms run longer on larger inputs. For example, it takes longer to sort larger arrays, multiply larger matrices, and so on. Therefore, it is logical to investigate an algorithms efficiency as a function of some parameter n indicating the algorithms input size. In most cases, selecting such a parameter is quite straightforward. the problem of evaluating a polynomial

12

Introduction

p(x) = anxn + . . . + a0 of degree n, It will be the polynomials degree or the number of its coefficients, which is larger by 1 than its degree. a parameter indicating an input size does matter. One such example is computing the product of two n n matrices. There are two natural measures of size for this problem. The first and more frequently used is the matrix order n. But the other natural contender is the total number of elements N in the matrices being multiplied. If the algorithm examines individual characters of its input, the user should measure the size by the number of characters. If it works by processing words, we should count their number in the input. The user should make a special note about measuring input size for algorithms solving problems such as checking primality of a positive integer n. Here, the input is just one number, and it is this numbers magnitude that determines the input size. In such situations, it is preferable to measure size by the number b of bits in the ns binary representation: b = _log2 n_ + 1

The user use some standard unit of time measurement will be second, or millisecond, and so on to measure the running time of a program implementing the algorithm. There are obvious drawbacks to such an approach, however: dependence on the speed of a particular computer, dependence on the quality of a program implementing the algorithm and of the compiler used in generating the machine code, and the difficulty of clocking the actual running time of the program. The thing to do is to identify the most important operation of the algorithm, called the basic operation, the operation contributing the most to the total running time, and compute the number of times the basic operation is executed. Let, cop be the execution time of an algorithms basic operation on a particular computer, and C(n) be the number of times this operation needs to be executed for this algorithm. Then we can estimate the running time T (n) of a program implementing this algorithm by the formula T (n) copC(n).

13

Introduction

The count C(n) does not contain any information about operations that are not basic, and, in fact, the count itself is often computed only approximately. The constant cop is also an approximation whose reliability is not always easy to assess. Still, unless N is extremely large or very small, the formula can give a reasonable estimate of the algorithms running time. How much faster would this algorithm run on a machine that is 10 times faster than th e one we have? The answer is, obviously, 10 times. Or, assuming that ( ) ( )

How much longer will the algorithm run if we double its input size? The answer is about four times longer.

( ) =

=

n(n-1) n2- n n2

and therefore,

CopC(2n)

( ) ( )

(2n)2 n2

CopC(n)

Orders of growth: The magnitude of the numbers in has a profound significance for the analysis of algorithms. The function growing the slowest among these is the logarithmic function.

14

Introduction

It consider only the leading term of a formula. It ignore the constant coefficient.

700

600

500

n*n*n

400

300

200

100

0 1 2 3 4 5 6 7 8

with a logarithmic basic-operation count to run practically instantaneously on inputs of all realistic sizes.

Algorithms that require an exponential number of operations are practical for solving only problems of very small sizes.

Worst-Case, Best-Case, and Average-Case Efficiency: An algorithms efficiency as a function of a parameter indicating the size of the algorithms input. But many algorithms measure the running time depends not only on an input size but also on the specifics of a particular input. Example: Sequential Search Problem: Given a list of n elements and a search key K, find an element equal to K, if any.

15

Introduction

Algorithm: Scan the list and compare its successive elements with K until either a matching element is found (successful search) of the list is exhausted (unsuccessful search) Sequential Search Algorithm: 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: Returns the index of the first element of A that matches K or 1 if there are no matching elements i 0 while i < n and A[i] K do ii+1 if i < n //A[I] = K return i else return -1

Worst case efficiency: 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 inputs of that size.

Cworst(n) = 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.

Cbest(n) = 1

Average case efficiency: However, that neither the worst-case analysis nor its best-case counterpart yields the necessary information about an algorithms behavior on a typical or random input. This is the information that the average-case efficiency seeks to provide. The standard assumptions are that (a) the probability of a successful search is equal to p (0 p 1) (b) the probability of the first match occurring in the ith position of the list is the same for every i. Cavg(n)

16

Introduction

Cavg(n) =

( ( (

( )

) )

) (

( )

For example, if p = 1 (the search must be successful), the average number of key comparisons made by sequential search is (n + 1)/2 i.e, the algorithm will inspect, on average, about half of the lists elements. If p = 0 (the search must be unsuccessful), the average number of key comparisons will be n because the algorithm will inspect all n elements on all such inputs. Another type of efficiency is called amortized efficiency

Recapitulation of the Analysis Framework: Both time and space efficiencies are measured as functions of input size. Time efficiency is measured by counting the number of basic operations executed in the algorithm. The space efficiency is measured by counting the number of extra memory units consumed by the algorithm. The frameworks primary interest lies in the order of growth of the algorithms running time (space) as its input size goes infinity. The efficiencies of some algorithms may differ significantly for inputs of the same size.

Asymptotic Notations:

There are three notations used to compare orders of growth of an algorithms basic operation count indicates the efficiency of an algorithm O(g(n)): class of functions f(n) that grow no faster than g(n) (g(n)): class of functions f(n) that grow at least as fast as g(n) (g(n)): class of functions f(n) that grow at same rate as g(n)

Big O-notation: Definition: A function t(n) is said to be in O(g(n)), denoted t(n) O(g(n)), if t(n) is bounded above by some constant multiple of g(n) for all large n, i.e., if there exist some positive constant c and some nonnegative integer n0 such that

Introduction

Example:

O(g(n)).

100n + 5 O(n2) So 100n + 5 100n + n (for all n 5) 101n 101n2., The values of the constants c and n0 required, we take 101 and 5. Big -notation (Omega):

A function t(n) is said to be in (g(n)), denoted t(n) (g(n)), if t(n) is bounded below by some constant multiple of g(n) for all large n, i.e., if there exist some positive constant c and some nonnegative integer n0 such that

18

Introduction

Big -notation (Theta):

(g(n)).

A function t(n) is said to be in (g(n)), denoted t(n) (g(n)), if t(n) is bounded both above and below by some positive constant multiples of g(n) for all large n, i.e., if there exist some positive constant c1 and c2 and some nonnegative integer n0 such that

For example, let us prove that First, we prove the right inequality (the upper bound):

19

Introduction

t (n)

(g(n)).

n(n 1) = n2 -

n n2 , C2 =

n n

n2 for all n 2

Theorem

If t1(n) O(g1(n)) and t2(n) O(g2(n)), then t1(n) + t2(n) O(max{g1(n), g2(n)}). The analogous assertions are true for the -notation and -notation.

20

Introduction

PROOF: The proof extends to orders of growth the following simple fact about four arbitrary real numbers a1, b1, a2, b2: if a1 b1 and a2 b2, then a1 + a2 2 max{b1, b2}. Since t1(n) O(g1(n)), there exist some positive constant c1 and some nonnegative integer n1 such that

Similarly, since t2(n) O(g2(n)),

Let us denote c3 = max{c1, c2} and consider n max{n1, n2} so that it can use both inequalities.

t1(n) + t2(n) c1g1(n) + c2g2(n) c3g1(n) + c3g2(n) c3[g1(n) + g2(n)] c32 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 O definition being 2c3 = 2 max{c1, c2} and max{n1, n2}, respectively. So what does this property imply for an algorithm that comprises two consecutively executed parts? It implies that the algorithms overall efficiency is determined by the part with a higher order of growth, i.e., its least efficient part:

t1(n) t2(n)

t1(n) + t2(n) )

O(g1(n)) O(g2(n))

O(max{g1(n), g2(n)}).

For example, First, sort the array by applying some known sorting algorithm; Second, scan the sorted array to check its consecutive elements for equality. For example, if a sorting algorithm used in the first part makes no more than n(n 1) comparisons (and hence is in o(n2)) while the second part makes no more than n 1 comparisons (and hence is in o(n)), the efficiency of the entire algorithm will be in o(max{n2, n}) = o(n2).

21

Introduction

Using Limits for Comparing Orders of Growth: The formal definitions of O, and are indispensable for proving their abstract properties, they are rarely used for comparing the orders of growth of two specific functions. A much more convenient method for doing so is based on computing the limit of the ratio of two functions in question. Three principal cases may arise: If

n

( ) ( )

= C implies that f(n) has the same order of growth as g(n), then f(n)

O(g(n))

lim n

n(n-1)

lim n

n2 - n

n2

lim n

1-

=

Since the limit is equal to a positive constant, the functions have the same order of growth

n (n-1)

n2

Basic Efficiency classes: The efficiency analysis framework puts together all the functions Whose orders of growth differ by a constant multiple, there are still infinitely many classes. For example, the exponential functions an have different orders of Growth for different values of base a. If 2 algorithms performs same task, the first one has computing time of O(n) and the second one has O(n2) then the first one is preferred.

22

Introduction

Basic Asymptotic classes: Class 1 n n2 n3 2n log n n log n Names Constant Linear Quadratic Cubic Exponential Logarithm n log n

Comments Best case efficiency List of size by n Algorithm contain 2 loops Algorithm contain 3 loops Generate all the subsets n element Cutting a problem size by a constant factor Many divide and conquer method algorithm

Non Recursive algorithm: It is executed only once to solve the problem. Example: Finding the largest element in a given array Algorithm MaxElement (A[0..n-1]) //Determines the value of the largest element in a given array //Input: An array A[0..n-1] of real numbers //Output: The value of the largest element in A maxval A[0] for i 1 to n-1 do if A[i] > maxval maxval A[i] return maxval Algorithm efficiency: Basic operation: Let us denote C(n) the number of times this comparison is executed and try to find a formula expressing it as a function of size n. The algorithm makes one comparison on each execution of the loop, which is repeated for each value of the loops variable i within the bounds 1 and n 1, inclusive. Therefore, we get the following sum for C(n):

n-1

C(n) =

1

i=1

23

Introduction

This is an easy sum to compute because it is nothing other than 1 repeated n 1 times. Thus,

n-1

C(n) =

1= n 1

i=1

(n).

Steps in mathematical analysis of nonrecursive algorithms: 1. Decide on parameter n indicating input size 2. Identify the basic operation of algorithm 3. Check whether the number of times the basic operation is executed depends only on the input size n. If it also depends on the type of input, investigate worst, average, and best case efficiency separately. 4. Set up a sum expressing for C(n) reflecting the number of times the algorithms basic operation is executed. 5. Using standard formulas and rules of sum manipulation either find a closedform formula for the count or, at the very least, establish its order of growth. we use especially frequently two basic rules of sum manipulation,

u u

i

cai = C a

i=1 i=1

(R1)

u u

i i

(a i

i=1

b i)

a b

i=1 i=1

(R2)

24

Introduction

Example 2: Consider the element uniqueness problem: check whether all the elements in a given array of n elements are distinct. This problem can be solved by the following straightforward algorithm. ALGORITHM UniqueElements(A[0..n 1]) //Determines whether all the elements in a given array are distinct //Input: An array A[0..n 1] //Output: Returns true if all the elements in A are distinct // and false otherwise for i 0 to n 2 do for j i + 1 to n 1 do if A[i]= A[j ] return false return true The natural measure of the inputs size here is again n, the number of elements in the array. Since the innermost loop contains a single operation (the comparison of two elements), the user should consider it as the algorithms basic operation. Note, however, that the number of element comparisons depends not only on n but also on whether there are equal elements in the array and, if there are, which array positions they occupy. The user will limit our investigation to the worst case only. By definition, the worst case input is an array for which the number of element comparisons Cworst(n) is the largest among all arrays of size n. An inspection of the innermost loop reveals that there are two kinds of worst-case inputsinputs for which the algorithm does not exit the loop prematurely: arrays with no equal elements and arrays in which the last two elements are the only pair of equal elements. For such inputs, one comparison is made for each repetition of the innermost loop, i.e., for each value of the loop variable j between its limits i + 1 and n 1; this is repeated for each value of the outer loop, i.e., for each value of the loop variable i between its limits 0 and n 2. Accordingly we get,

25

Introduction

Note: This result was perfectly predictable: in the worst case, the algorithm needs to compare all n(n 1)/2 distinct pairs of its n elements. EXAMPLE 3 :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. By definition, C is an n n matrix whose elements are computed as the scalar (dot) products of the rows of matrix A and the columns of matrix B: A B C

row i

C[i,j]

col .j where,

for every pair of indices 0 i, j n 1.

Algorithm MatrixMultiplication (A[0..n-1, 0..n-1], B[0..n-1, 0..n-1] ) //Multiplies two square matrices of order n by the definition-based algorithm //Input: two n-by-n matrices A and B //Output: Matrix C = AB for i 0 to n - 1 do for j 0 to n 1 do C[i, j] 0.0 for k 0 to n 1 do C[i, j] C[i, j] + A[i, k] * B[k, j] return C

26

Introduction

To measure an inputs size by matrix order n. There are two arithmetical operations in the innermost loopmultiplication and additionthat, in principle, can compete for designation as the algorithms basic operation. Let us set up a sum for the total number of multiplications M(n) executed by the algorithm. Obviously, there is just one multiplication executed on each repetition of thealgorithms innermost loop, which is governed by the variable k ranging from the lower bound 0 to the upper bound n 1. Therefore, the number of multiplications made for every pair of specific values of variables i and j is

The total number of multiplications M(n) is expressed by the following triple sum:

Now, we can compute this sum by using formula (S1) and rule (R1) given above. Starting with the innermost sum ,

To estimate the running time of the algorithm the user can do it by the product

where Cm is the time of one multiplication. We would get a more accurate estimate if we took into account the time spent on the additions, too:

27

Introduction

where ca is the time of one addition. The user should not have the erroneous impression that always succeeds in analyzing a nonrecursive algorithm. An irregular change in a loop variable, a sum too complicated to analyze, and the difficulties intrinsic to the average case analysis are just some of the obstacles that can prove to be insurmountable

Example: 4 The following algorithm finds the number of binary digits in the binary representation of a positive decimal integer Algorithm Binary(n) //Input: A positive decimal integer n (stored in binary form in the computer) //Output: The number of binary digits in ns binary representation count 0 while n >= 1 do //or while n > 0 do count count + 1 n n/2 return count First, notice that the most frequently executed operation is not inside the while loop but rather the comparison n > 1 that determines whether the loops body will be executed. Since the number of times the comparison will be executed is larger than the number of repetitions of the loops body by exactly 1, the choice is not that important. A more significant feature of this example is the fact that the loop variable takes on only a few values between its lower and upper limits. Therefore, the user has to use an alternative way of computing the number of times the loop is executed. Since the value of n is about halved on each repetition of the loop, the answer should be about log2 n. The exact formula for the number of times the comparison n>1 will be executed is actually [log2 n] + 1. The number of bits in the binary representation of n according to formula. The user could also get the result by applying the analysis technique based on recurrence relations.

28

Introduction

Recursive Algorithm: The general framework for analysis of algorithms to recursive algorithms, the algorithm executed recursively until it met a condition. EXAMPLE 1 Compute the factorial function F(n) = n! for an arbitrary nonnegative integer n. Since n!= 1 . . . . . (n 1) . n = (n 1)! . n for n 1 and 0!= 1 by definition, we can compute F(n) = F(n 1) . n with the following recursive algorithm. ALGORITHM F(n) //Computes n! recursively //Input: A nonnegative integer n //Output: The value of n! if n = 0 return 1 else return F(n 1) ! . n To consider n itself as an indicator of this algorithms input size. The basic operation of the algorithm is multiplication,5 whose number of executions we denote M(n). Since the function F(n) is computed according to the formula

The number of multiplicationsM(n) needed to compute it must satisfy the equality

M(n) = M(n 1) +

To compute F(n-1)

To multiply F(n-1) by n

Indeed, M(n 1) multiplications are spent to compute F(n 1), and one more multiplication is needed to multiply the result by n. The last equation defines the sequence M(n) that we need to find. This equation defines M(n) not explicitly, i.e., as a function of n, but implicitly as a function of its value at another point, namely n 1. Such equations are called recurrence relations or, for brevity, recurrences. Recurrence relations play an important role not only in analysis of algorithms but also in some areas of applied mathematics. To solve the recurrence relation M(n) = M(n 1) + 1, i.e., to find an explicit formula for M(n) in terms of n only.

29

Introduction

Note, however, that there is not one but infinitely many sequences that satisfy this recurrence. To determine a solution uniquely, we need an initial condition that tells us the value with which the sequence starts. We can obtain this value by inspecting the condition that makes the algorithm stop its recursive calls:

if n = 0 return 1.

It tells two things: 1. First, since the calls stop when n = 0, the smallest value of n for which this algorithm is executed and hence M(n) defined is 0. 2. Second, by inspecting the pseudocodes exiting line, we can see that when n = 0, the algorithm performs no multiplications. Thus, the initial condition

M(0) = 0

Thus, they succeeded in setting up the recurrence relation and initial condition for the algorithms number of multiplications M(n): M(n) = M(n 1) + 1 for n > 0, (2.2) M(0) = 0. They dealing here with two recursive functions The first is the factorial function F(n) itself; it is defined by the recurrence F(n) = F(n 1) . n for every n > 0, F(0) = 1. The second is the number of multiplicationsM(n) needed to compute F(n) by the recursive algorithm. Among several techniques available for solving recurrence relations, can be called the method of backward substitutions. The idea to solving our particular recurrence: M(n) = M(n 1) + 1 substitute M(n 1) = M(n 2) + 1 = [M(n 2) + 1]+ 1= M(n 2) + 2 substitute M(n 2) = M(n 3) + 1 = [M(n 3) + 1]+ 2 = M(n 3) + 3. After inspecting the first three lines, which makes it possible to predict not only the next line but also a general formula for the pattern:M(n) = M(n i) + i. Strictly speaking, the correctness of the formula should be proved by mathematical induction, but it is easier to get to the solution as follows and then verify its correctness. What remains to be done is to take advantage of the initial condition given. Since it is specified for n = 0, we have to substitute i = n in the patterns formula to get the ultimate result of our backward substitutions:

30

Introduction

The benefits of the method illustrated in this simple example will become clear very soon, when we have to solve more difficult recurrences. Note: The simple iterative algorithm that accumulates the product of n consecutive integers requires the same number of multiplications, and it does so without the overhead of time and space used for maintaining the recursions stack. The issue of time efficiency is actually not that important for the problem of computing n!. The functions values get so large so fast that user can realistically compute exact values of n! only for very small ns.

General Plan for Analyzing the Time Efficiency of Recursive Algorithms 1. Decide on a parameter (or parameters) indicating an inputs size. 2. Identify the algorithms basic operation. 3. Check whether the number of times the basic operation is executed can vary on different inputs of the same size; if it can, the worst-case, average-case, and best-case efficiencies must be investigated separately. 4. Set up a recurrence relation, with an appropriate initial condition, for the number of times the basic operation is executed. 5. Solve the recurrence or, at least, ascertain the order of growth of its solution. Example: 2 Tower of Hanoi Problem There are n disks of different sizes that can slide onto any of three pegs. Initially, all the disks are on the first peg in order of size, the largest on the bottom and the smallest on top. The goal is to move all the disks to the third peg, using the second one as an auxiliary, if necessary. The user can move only one disk at a time, and it does not place a larger disk on top of a smaller one. The problem has an elegant recursive solution, which is illustrated in the diagram. To move n>1 disks from peg 1 to peg 3 (with peg 2 as auxiliary) First, move recursively n 1 disks from peg 1 to peg 2 (with peg 3 as auxiliary), then move the largest disk directly from peg 1 to peg 3. Finally, move recursively n 1 disks from peg 2 to peg 3 (using peg 1 as auxiliary). If n = 1, move the single disk directly from the source peg to the destination peg.

31

Introduction

CV

Destination peg

Source peg

2

Let us apply the general plan outlined above to the Tower of Hanoi problem. The number of disks n is the obvious choice for the inputs size indicator, and so is moving one disk as the algorithms basic operation. The number of moves M(n) depends on n only, and we get the following recurrence equation for it:

With the obvious initial condition M(1) = 1, we have the following recurrence relation for the number of moves M(n):

32

Introduction

To solve this recurrence by the same method of backward substitutions:

M(n) = 2M(n 1) + 1 sub. M(n 1) = 2M(n 2) + 1 2 = 2[2M(n 2) + 1]+ 1= 2 M(n 2) + 2 + 1 sub. M(n 2) = 2M(n 3) + 1 = 22[2M(n 3) + 1]+ 2 + 1= 23M(n 3) + 22 + 2 + 1.

The pattern of the first three sums on the left suggests that the next one will be 24M(n 4) + 23 + 22 + 2 + 1, and generally, after i substitutions, we get

Since the initial condition is specified for n = 1, which is achieved for i = n 1, we get the following formula for the solution to recurrence (2.3):

M(n) = 2n1M(n (n 1)) + 2n1 1 = 2n1M(1) + 2n1 1= 2n1 + 2n1 1= 2n 1. Fig:Tree of recursive calls made by the recursive algorithm for the Tower of Hanoi n

n-1

n-1

n-2

n-2

n-2

n-2

1 1 1 1 1

33

Introduction

When a recursive algorithm makes more than a single call to itself, it can be useful for analysis purposes to construct a tree of its recursive calls. In this tree, nodes correspond to recursive calls, and we can label them with the value of the parameter (or, more generally, parameters) of the calls. For the Tower of Hanoi example, the tree is given in the diagram, by counting the number of nodes in the tree, the user can get the total number of calls made by the Tower of Hanoi algorithm:

C(n) =

The number agrees, as it should, with the move count obtained earlier.

Example: 3 Find the number of binary digits in the binary representation of a positive decimal integer (A recursive solution) Algorithm BinRec(n) //Input: A positive decimal integer n (stored in binary form in the computer) //Output: The number of binary digits in ns binary representation if n = 1 //The binary representation of n contains only one bit. return 1 else //The binary representation of n contains more than one bit. return BinRec( n/2) + 1 Let us a recurrence and an initial condition for the number of additions A(n) made by the algorithm. The number of additions made in computing BinRec(_n/2_) is A(_n/2_), plus one more addition is made by the algorithm to increase the returned value by 1. This leads to the recurrence A(n) = A(_n/2_) + 1 for n > 1. (2.4) Since the recursive calls end when n is equal to 1 and there are no additions made then, the initial condition is A(1) = 0. The presence of _n/2_ in the functions argument makes the method of backward substitutions stumble on values of n that are not powers of 2. Therefore, the standard approach to solving such a recurrence is to solve it only for n = 2k and then take advantage of the theorem called the smoothness rule, which claims that under very broad assumptions the order of growth observed for n = 2k gives a correct answer about the order of growth for all values of n. (Alternatively, after getting a solution for powers of 2, we can sometimes fine-tune this solution to get a formula valid for an arbitrary n.) So let us apply this to recurrence, which for n = 2k takes the form

34

Introduction

A(2k) = A(2k1) + 1 for k > 0, A(20) = 0.

Now backward substitutions encounter no problems: A(2k) = A(2k1) + 1 substitute A(2k1) = A(2k2) + 1 = [A(2k2) + 1]+ 1= A(2k2) + 2 substitute A(2k2) = A(2k3) + 1 = [A(2k3) + 1]+ 2 = A(2k3) + 3 . . . ... = A(2ki) + i ... = A(2kk) + k. Thus, we end up with A(2k) = A(1) + k = k, or, after returning to the original variable n = 2k and hence k = log2 n, A(n) = log2 n (log n).

In fact, one can prove that the exact solution for an arbitrary value of n is given by just a slightly more defined formula A(n) =[log2 n]

35

- 258 Data Structures Interview Questions and AnswersUploaded bychotaajay
- CS8251-Programming in C NotesUploaded byA Mary Aruldas
- Introduction to Algorithms, Second Edition ( PDFDrive.com ).pdfUploaded byraj
- New SyllabusUploaded byAditya Sawant
- lec37-nov03Uploaded byMukesh Kumar Dewra
- 1.1 Basic Data Structure (2)Uploaded byhimanshuchawla654
- daa prev final.docxUploaded bymanikanta
- Ge8161-Pspp Lab ManualUploaded bybalakiruba
- Big O NotationUploaded byFthalew Ashagrie
- SA ImplementationsUploaded byAbhishek Mallick
- Google GuideUploaded byJacky Liang
- Billion-scale Similarity Search With GPUsUploaded byergodic
- big_oUploaded byJosé Abel Castellanos Joo
- CS372_SyllabusUploaded byLaura Craig
- Big O Algorithm Complexity Cheat SheetUploaded byShreyans Pathak
- algorithm = logic + control.pdfUploaded bytom-844468
- Slides Algo-Inversions2 TypedUploaded byigoysingh
- coding questions.docxUploaded byKaivalya Dabhadkar
- ptoticAnalysisUploaded bypullasunil
- sortingalgorithms-1232354736607028-2Uploaded bydosyaejje
- AlgorithmUploaded byYessica Rosas
- Ps1 Solution(VERY IMP)Uploaded byOmega Man
- Big o Complexty ExamplesUploaded byAdnan Khan
- Computer Science-Lecture 9-Final IssuesUploaded byAshley Anderson
- Davis 2011Uploaded byVitthal Patnecha
- Lecture 03Uploaded byBraicot Espinoza Moran
- Chap8 SolutionsUploaded byForm 4B
- 05655365Uploaded byAnh Hung
- Aptitude 13Uploaded bymuthupecmec4908
- pxc3873876Uploaded byLalit Sharma

- Forced Convection Over a Flat Plate by Finite Difference MethodUploaded byNihanth Wagmi
- 59766045-II-b-tech-Cse-r10-Jntuk-Syllabus.docUploaded byChristina Robinson
- Lecture#18(1)Uploaded byNew1122
- 10-6Uploaded byksr131
- 2010_TJC_Sol.docUploaded byPooja Kapur
- dsp_manual_newUploaded byMuktha Mini
- CombinotoricsUploaded byMadhur Sahu
- Literature Review Assignment #1Uploaded bymrdesta
- Algorithm AnalysisUploaded bybeenagodbin
- 15-2Uploaded byksr131
- 00000588Uploaded byAvinav Kumar
- Methods Pages2011Uploaded byimran.koradia
- LectUploaded bysifat
- 6_numerical Methods for Chemical Engineers With Matlab ApplicationsUploaded byGonzalo1959
- Math DiskritUploaded bynenaibrahim
- cloud computing CSE syllabusUploaded bysubramanyam62
- Solving RecurrencesUploaded bybmandar
- 836312 Digital Control Engineering 2nd Edition Fadali Solution Manual.doc254405506Uploaded bychyntia
- Chapter 1Uploaded byAdrian Tan
- cssyllabus 3rdUploaded byKiran Kumar
- Pearson Final Hiperg CompUploaded byMarcelo Fiori
- Mathematics Higher 6th EditionUploaded bycallumt95
- MIT18_310F13_Ch7Uploaded bybhar
- A Study on Properties of Regularity for Fractional Difference Equations in Stochastic ProcessesUploaded byIJSRP ORG
- UG Syllabus corrected .pdfUploaded bysujithrengan_9019266
- Difference Equations & Z-transformsUploaded byvidya_sagar826
- rec2Uploaded byercassiosantos
- Solving RecurancesUploaded bySam McGuinn
- vit university syallabusUploaded bypranavateja12399
- FibonacciUploaded byChristelle Joy Eusebio