n

f(n) c*g(n)

n0

n

f(n) c1*g(n

)

c2*g(n)

n0

KAMARAJ COLLEGE OF ENGINEERING AND TECHNOLOGY

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

1. Metrics used to measure the efficiency of an algorithm:

Time Complexity

Space Complexity

2. Divide and Conquer Strategy:

Splitting the �n� inputs into �k� distinct subsets, 1 < k ≤ n, yielding �k� number of

sub problems. These problems must be solved.

Type DandC(P)

{

if small(P) return S(P);

else {

divide P into smaller instances P1, P2, .. Pk k>=1;

Apply DandC to each of these sub problems;

return Combine (DandC(P1),�..DandC(Pk));

}

}

3. Big � Omega notation:

T (n) = f (n) = Ù (g (n))

- If f (n) >= c*g (n) for all n > n0, where c and n0 are constants > 0

Ù (g (n)): class of functions f (n) that grow at least as fast as g (n)

4. Big Theta notation:

T (n) = f (n) = È (g (n))

- If c1*g (n) <= f (n) <= c2*g (n) for all n > n0, where c1, c2 and n0 are

constants > 0.

È (g (n)): class of functions f (n) that grow at same rate as g (n)

id1716869 pdfMachine by Broadgun Software - a great PDF writer! - a great PDF creator! - http://www.pdfmachine.com http://www.broadgun.com

5. Container Loading Problem:

Large ship is to be loaded with cargos.

Cargo is containerized.

All containers are same in size & different in weights.

wi - weight of the ith container.

Cargo capacity of the ship is �C�.

Problem is to load the ship with maximum number of containers.

Feasible solution

n ∑ wixi ≤ c and xiå {0,1} , 1 ≤i ≤n

i=1 x=1 �> container is to be loaded x= 0 -> container is not to be loaded

Objective function n Maximize ∑ xi

i=1

6. Big Oh notation:

T (n) = f (n) = O (g (n))

- If f (n) <= c*g (n) for all n ≥ n0, where c & n0 are constants > 0

O (g (n)): class of functions f (n) that grow no faster than g (n)

Properties of Big Oh notation:

O (f (n)) + O ( g(n)) = O (max { f (n), g (n)})

f (n) = O (g (n)) and g (n) ≤ h (n) implies f (n) = O ( h (n))

Any function can be said as an order of itself. i.e., f (n) = O (f (n))

Any constant value is equivalent to O (1). i.e., C = O (1)

If limn→∞ {f (n) / g (n)} å R>0 then f (n) å È (g (n)).

If limn→∞ {f (n) / g (n)} = 0 then f (n) å O (g (n)) but f (n) not å È (g (n)).

If limn→∞ {f (n) / g (n)} = +∞ => f (n) å Ù (g(n)) but f (n) not å È (g (n)).

7. a) Solve the following recurrence relation.

n

c*g(n) f(n)

n0

S(K)-4S(K-1)+4S(K-2)=3K+2K

Initial conditions are S(0) = 1, S(1) = 1 Soln:

Characteristic Equation is,

a2 - 4a + 4 = 0

Roots are 2,2

SH(K) = (b0+b1K)2K

Sp1(K)=(K2/2)2K

Sp2(K)=12+3K

S(K)=(-11+(7/2)K) 2K +(K2/2)2K +12+3K 7. b) Merge Sort:

void MergeSort (int low, int 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<high)

{// If there are more than one element // Divide P into sub problems. // Find where to split the set. int mid = (low+high)/2; // Solve the sub problems MergeSort (low, mid); MergeSort (mid +1, high); // Combine the solutions Merge (low, mid, high);

} }

void Merge (int low, int mid, int high) /* a[low: high] is a global array containing two sorted subsets in a[low: high] and in a [mid +1: high]. The goal is to merge these two sets into a single set residing in a a[low: high]. b [] is an auxiliary global array. { int h = low, i= low, j= mid+1, k; while (( h<= mid) && (j<=high))

{ if (a[h] <= a[j]) { b[i] = a[h]; h++; } else { b[i] = a[j]; j++; } } if ( h > mid) { for ( k=j; k<=high; k++) { b[i] = a[k]; i++; } } else { for ( k=h; k<=mid; k++) { b[i]=a[k];

i++; } } for (k=low; k<=high; k++) { a[k] = b[k]; }

}

Merge sort for the following elements: 310, 285, 179, 652, 351, 423, 861, 254, 450,

and 520.

Solution:

Given a [10] = 310, 285, 179, 652, 351, 423, 861, 254, 450, 520

Step 1: (350 | 285 | 179 | 652, 351 | 423, 861, 254, 450, 520) � split a [] into (a

[1:5] and a [6:10]), then a [1:5] into (a [1:3] and a [4:5]). Then a [1:3] into (a [1:2]

and a [3:3]). The two values in a [1:2] are split a final time into single element sub

arrays.

Step 2: (285, 310 | 179 | 652, 351 | 423, 861, 254, 450, 520) � a [1] and a [2] are

merged.

Step 3: (179, 285, 310 | 652, 351 | 423, 861, 254, 450, 520) � a [3] is merged with

a [1:2]

Step 4: (179, 285, 310 | 351, 652 | 423, 861, 254, 450, 520) � a [4] and a [5] are

merged.

Step 5: (179, 285, 310, 351, 652 | 423, 861, 254, 450, 520) � a [1:3] and a [4:5]

are merged.

Step 6: (179, 285, 310, 351, 652 | 423 | 861 | 254 | 450, 520) � a [6:10] is split

into

a [6:8] and a [9:10], then a [6:8] into a [6:7], a [8:8].Then a [6:7] into individual

element sub arrays.

Step 7: (179, 285, 310, 351, 652 | 423,861 | 254 | 450, 520) � a [6] and a [7] are

merged.

Step 8: (179, 285, 310, 351, 652 | 254, 423, 861| 450, 520) � a [8] is merged with

a [6:7].

Step 9: (179, 285, 310, 351, 652 | 254, 423, 450, 520, 861)

Step 10: (179, 254, 285, 310, 351, 423, 450, 520, 652, 861)

8. Knapsack Problem using Greedy Approach:

� �n� objects & a bag(knapsack)

� wi is weight of the object i.

� If object �i� is place into the bag, it will give pi xi profit, where xi is fraction

value 0≤ xi ≤1

� �m� is capacity of knapsack

Algorithm:

void GreedyKnapsack(float m, int n) //objects are ordered by ratio of p&w

{

for(int i=1; i<=n; i++)

{

x[i]=0.0;

}

float u=m;

for(int i=0; i<=n; i++)

{

if(w[i] > u) break;

x[i]=1.0;

u-=w[i];

}

if(i<=n) x[i] = u/w[i];

}

Problem:

Item Weight Values

1 8 $64

2 7 $63

3 6 $60

4 4 $12

W=16

(p1/w1, p2/w2, p3/w3, p4/w4) = (8, 9, 10, 3)

wi xi wixi pi pixi

w3 6 1 6 60 60

w2 7 1 7 63 63

w1 8 3/8 3 64 24

w4 4 0 0 12 0

Total 16 Total 147

(x1, x2, x3, x4) = (3/8,1,1,0)