daa anskey

8/10/2019 Daa Anskey

1/14

BTECH DEGREE EXAMINATION,MAY2014

CS010 601 DESIGN AND ANALYSIS OF ALGORITHMS

ANSWER KEY

PART-A

1.

A recursive algorithm is an algorithm which calls itself with "smaller (or

simpler)" input values, and which obtains the result for the current input by

applying simple operations to the returned value for the smaller (or

simpler) input.

int factorial(int n)

{

if (n == 0)

return 1;

else

return (n * factorial(n-1));

}

2.

Control abstraction means a procedures whose flowof control is clear but

whose primary operations are specified by other procedures whose precise

meanings are left defined.

3. MONTE CARLO METHOD

4. A minimum spanning tree is a least-cost subset of the edges of a graph that

connects all the nodes

Start by picking any node and adding it to the treeRepeatedly: Pick any least-costedge from a node in the tree to a node not in

the tree, and add the edge and new node to the tree

Stop when all nodes have been added to the tree

5. An ordering of the vertices in a directed acyclic graph, such that:If there is a path from uto v, then vappears after uin the ordering.


2/14

1. Compute the indegrees of all vertices

2. Find a vertex Uwith indegree 0 and print it (store it in the ordering)

If there is no such vertex then there is a cycleand the vertices cannot be ordered. Stop.

3. Remove Uand all its edges (U,V)from the graph.

4. Update the indegrees of the remaining vertices.

5. Repeat steps 2 through 4 while there are vertices to be processed.

PART B

6. Space Complexity:-Space complexity of an algorithm is the amount to

memory needed by the program for its completion.

The space requirement s(p) of any algorithm p may thereore be written

as s(p) =c+Sp, where c is a constant

Time Complexity:-Time complexity of an algorithm is the amount of

time needed by the program for its completion

Step count

Step per execution or Build a table

7.

Finding the Maximum And Minimum.

to find the minimum and maximum items in a list of numbers

Algorithm StraightMaxMin(a,n,max,min)

// Set max to the maximum and min to the minimum of a[1:n];

{

max=min=a[1];

for i=2 to n do

{

if (a[i]>max) then max=a[i];


3/14

if(a[i]


4/14

Many decision sequences may be generated.

9.

10.

DETERMINISTIC ALGORITHMS

Algorithms with the property that the result of every operation is uniquely defined are termed

deterministic.

Such algorithms agree with the way programs are executed on a computer.

Nondeterministic algorithms

In a theoretical framework we can allow algorithms to contain operations whose outcome is

not uniquely defined but is limited to a specified set of possibilities.

The machine executing such operations are allowed to choose any one of these outcomes

subject to a termination condition.

This leads to the concept of non deterministic algorithms.

PART C

2. ASYMPTOTIC NOTATIONS

Asymptotic efficiency of algorithms concerned with how the running time of

an algorithm increases with he size of the input in the limit.The notations used

to decribe the asymptotic efficiency of an algorithm is called asymptotic

notations.Asymptotic complexity

is a way of expressing the main component

of the cost of an algorithm, using idealized units of computational work. Note

that we have been speaking about boundson the performance of algorithms,

rather than giving exact speeds.

Different asymptotic Notations are,

Big Oh

Omega

Theta

Little oh

Little omega

BIG-OH NOTATION (O)


5/14

Big-O is the formal method of expressing the upper bound of an

algorithm's running time. It's a measure of the longest amount of time it

could possibly take for the algorithm to complete.

Defenition

Given functions f(n)and g(n), we say that f(n)= O(g(n)) if and only if

there are positive constants cand n0such thatf(n) c g(n)for n n0for

the algorithm to complete.

Omega Notation ()

Definition

Given functions f(n)and g(n), we say thatf(n)= (g(n)) if and only if there are

positive constants cand n0such thatf(n)c g(n)for n n0.

It is the lower bound of any function. Hence it denotes the best case complexity of

any algorithm. We can represent it graphically as


6/14

Theta Notation ()

Definition

Given functions f(n)and g(n), we say that f(n)= (g(n)) if and only if there arepositive constants c1,c2and n0such that c1g(n)f(n) c2g(n) for n n0.

The theta notation is more precise than both the big oh and big omega notations.

The function f(n)=theta(g(n)) iff g(n) is both lower and upper bound of f(n).

13, Matrix Multiplication Algorithms:

When multiplying two 2 2 matrices [Aij] and [Bij]


7/14

The resulting matrix [Cij] is computed by the equations

C11=A11B11+A12B21

C12=A11B12+A12B22

C21=A21B11+A22B21

C22=A21B12+A22B22

When the size of the matrices are nn,the amount of computation is O(n3), because there are

n2entries in the product matrix where each require O(n) time to compute.

Strassens Matrix Multiplication

Strassens Algorithm (two 2x2 matrices)

c11 c12 a11 a12 b11 b12

= *

c21 c22 a21 a22 b21 b22

P + S - T+ V R+ T

=

Q + S P + RQ + U

P = (a11+ a22) * (b11+ b22)

Q = (a21+ a22) * b11

2221

1211

2221

1211

2221

1211

CC

CC

BB

BB

AA

AA


8/14

R = a11* (b12- b22)

S= a22* (b21- b11)

T = (a11+ a12) * b22

U= (a21- a11) * (b11+ b12)

V = (a12- a22) * (b21+ b22)

7 multiplications

18 additions / subtractions

The resulting recurrence relation for T(n) is

Where

n is a power of 2, n=2kfor some integer k.

a and b are constant.

14.

Divide:divide array A[0..n-1] in two about equal halves and make copies of each half in arrays B

and C

Conquer:

If number of elements in B and C is 1, directly solve it

Sort arrays B and C recursively

Combine:Merge sorted arrays B and C into array A

Repeat the following until no elements remain in one of the arrays:

compare the first elements in the remaining unprocessed portions of the arrays

B and C


9/14

copy the smaller of the two into A, while incrementing the index indicating the

unprocessed portion of that array

Once all elements in one of the arrays are processed, copy the remaining unprocessed

elements from the other array into A.

Algorithm MergeSort(low,high)

//a[low:high] is a global array to be sorted. Small(P) is true if there is only one element to sort.In this

case the list is already sorted.

{

if(low


10/14

//Solve the subproblems

MergeSort(low,mid);

MergeSort(mid+1,high);

// Combine the solutions

Merge(low,mid,high)

}

}

Algorithm Merge(low,mid,high)

//a[low:high] is a global array containing two sorted subset in a[low:mid] and in a[mid+1:high]. The goal

is to merge these two sets into a single set residing in a[low:high]. b[] is an auxilary global array.

{

h:=low; i:=low; j:=mid+1;

while((hmid) and (j high)) do

{

if(a*h+ a*j+) then

{

b[i]:=a[h]; h=h+1;

}

else

{

b[i]=a[j];j=j+1;

}

i=i+1;


11/14

}

if(h>mid)then

for k:= j to high do

{

b[i]=a[k];i=i+1;

}

else

for k:=h to mid do

{

b[i]:=a[k]; i=i+1;

}

for k:= low to high do

a[k]:=b[k];

}

If T(n) represent the time for the merging operation is proportional to n then the computing time for

merge sort is ,

Where n is a power of 2, n=2k

for some integer k.

c and a are constant.

15. Basics of Kruskals Algorithm

Edges are initially sorted by increasing weight

Start with an empty forest ,grow MST one edge at a time


12/14

intermediate stages usually have forest of trees (not connected)

at each stage add minimum weight edge among those not yet used that does not create a cycle

at each stage the edge may:

expand an existing tree

combine two existing trees into a single tree

create a new tree

need efficient way of detecting/avoiding cycles

algorithm stops when all vertices are included

Algorithm Kruskal(E,cost,n,t)

// E is the set of edges in G . G has n vertices. Cost[u,v] is the// cost of edge(u,v). T is the set of edges in the minimum-cost

//spanning tree. The finalcost is returned

{

construct a heap out of the edge costs using heapify;

for i=1 to n do parent[i]=-1;

// each vertex is in a different set.

i=0; mincost=0.0;

while((i


13/14

else return mincost;

}

The final set is

{1 2 3 4 5 6 7}

Analysis of Kruskal


14/14

(initialization): O(V)

(sorting): O(E log E)

(set-operation): O(E log E)

Total: O(E log E)

daa anskey

Documents