0 vues

- java programming II Final Exam Study Sheets
- Important Problem Types
- DFS and BFS algorithm
- Quick Sort
- DS Model Paper 2013 14
- Gondwana Univ - CAD-CAM
- HCL Commonly Asked Questions 2
- RA17M1B39_Homework 1_CSE408_algorollno39
- AI
- IJAIEM-2013-09-18-030.pdf
- 8.0 Environment Variables
- PIC10B_lecture14
- algorithm - Counting inversions in an array - Stack Overflow.htm.txt
- Array.pdf
- cloveretlclusterexplained-130814083119-phpapp01
- Lecture 02
- Design analysis of algos
- Resource Leveling
- Divide and Conquer
- Introduction to the Design and Analysis of Algorithms - Lecture Notes, Study Material and Important Questions, Answers

Vous êtes sur la page 1sur 22

Module- 2

Divide and Conquer

Given a function to compute on n inputs the divide-and-conquer strategy suggests splitting the inputs

into k distinct subsets, 1 < k < n, yielding k sub problems. These sub problems must be solved, and then

a method must be found to combine sub solutions into a solution of the whole.

If the sub problems are still relatively large, then the divide-and-conquer strategy can be reapplied. In

divide-and-conquer strategy when the input is split the sub problems are of the same kind as the original

problem. The reapplication of the divide-and-conquer principle is naturally expressed by a recursive

algorithm.

Algorithm DAndC(P)

2 {

3 if Small(P) then return S(P);

4 else

5 {

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

7 Apply DAndC to each of these subproblems;

8 return Combine(DAndC(P1),DAndC(P2),...,DAndC(Pk));

9 }

10 }

DAndC is initially invoked as DAndC(P), where P is the problem to be solved. Small(P) is a Boolean-

valued function that determines whether the input size is small enough that the answer can be computed

without splitting. If this is so, the function S is invoked. Otherwise the problem P is divided into smaller

sub problems. These sub problems P1 , P2, , Pk are solved by recursive applications of DAndC.

Combine is a function that determines the solution to P using the solutions to the k sub problems. If the

size of P is n and the sizes of the k sub problems are n1 , n2 , ... ,nk , respectively, then the computing time

of DAndC is described by the recurrence relation

_______2.1

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.

f (n) - is the time for dividing P and combining the solutions to sub problems.

For divide and- conquer-based algorithms that produce sub problems of the same type as the original

problem, it is very natural to first describe such algorithms using recursion. The complexity of many

divide-and-conquer algorithms is given by recurrences of the form

CSE@HKBKCE 1 2017-18

DAA Module-2

where a and b are known constants. We assume that T(1) is known and n is a power of b (i.e., n = bk ).

Master

Theorem

If f(n) (nd) where d>=0 in recurrence equation 2.1 then

Example -1

a=2,b=2 and let T(1)=2 and f(n)=n

Then

T(n) = 2*T(n/2) + n

Since f(n)=n,d=1

According to masters theorem a=bd

T(n) (nlogn)

Example-2

Since f(n)=c,d=0

According to masters theorem a=bd

T(n) (logn)

1. a=2,b=2,f(n)=cn

2. a=7,b=2 and f(n)=18n2

3. a=9,b=3 and f(n)= 4n6

4. a=1,b=2,f(n)=cn

5. a=5,b=4,f(n)=cn2

6. a=28,b=3,f(n)=cn3

CSE@HKBKCE 2 2017-18

DAA Module-2

Let ai , 1 i n, be a list of elements that are sorted in increasing order.

Binary search is the problem of determining whether a given element x is present in the list. If x

is present, we have to determine a value j such that aj = x. If x is not in the list, then j is to be set

to zero.

Let P = (n, al,…. ,au, x) denote an arbitrary instance of this search problem (n is the number of

elements in the list, al,…. , au is the list of elements, and x is the element searched for.

Let Small(P) be true if n = 1. In this case, S(P) will take the value i if x = ai , otherwise it will take

the value 0. Then g(1) = (1).

If P has more than one element, it can be divided into a new sub problem by picking an index q (in

the range [l,u]) and compare x with a[q]. There are three possibilities:

1. x = aq: In this case the problem P is immediately solved.

2. x < aq: In this case x has to be searched for only in the sublist ai, [al, • • •, aq-1].Therefore, P

reduces to (q-l, al ,... , aq-1 , x).

3. x > aq: In this case the sub list to be searched is aq+1, , au. P reduces to (u- q, aq+1, au, x).

In Binary search any given problem P gets divided (reduced) into one new sub problem. This

division takes only O(1)time. After a comparison with aq, the instance remaining to be solved (if

any) can be solved by using this divide-and-conquer scheme again. If q is always chosen such that

aq is the middle element (that is, q = [(l + u)/ 2), then the resulting search algorithm is known as

binary search. The answer to the new sub problem is also the answer to the original problem P.

There is no need for any combining.

Algorithm BinSrch is Recursive and has four inputs a[ ], I , 1, and x. It is initially invoked as

BinSrch(a, 1, n, x).

1.Algorithm BinSrch(a,l,u,x)

2 // Given an array a[l:u] of elements in nondecreasing

3 // order, l < l < u, determine whether x is present, and

4 // if so, return j such that x = a[j]; else return 0.

5{

6 if (1 = u) then // If Small ( P)

7{

8 if (x = a[l]) then return l;

9 else return 0;

10 }

11 else

12 { // Reduce P into a smaller subproblem.

13 mid := [(l +u)/2];

14 if (x = a[mid]) then return mid;

15 else if (x < a[mid]) then

16 return BinSrch(a, l, mid-1, x);

17 else return BinSrch(a, mid + 1,u,x);

18 }

19 }

CSE@HKBKCE 3 2017-18

DAA Module-2

2 // Given an array a[1 : n] of elements in nondecreasing

3 // order, n > 0, determine whether x is present, and

4 // if so, return j such that x = a[j]; else return 0.

5{

6 low := 1; high := n;

7 while (low < high) do

8{

9 mid := [(low + high)/2];

10 if (x < a[mid]) then high := mid -1;

11 else if (x > a[mid]) then low := mid + 1;

12 else return mid;

13 }

14 return 0;

15 }

Example:

Consider the set of elements

Index [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]

element -15 -6 0 7 9 23 54 82 101 112 125 131 142 151

When x=151

Low high mid

1 14 7

8 14 11

12 14 13

14 14 14

found

When x=-5

Low high mid

1 14 7

1 6 3

1 2 1

2 2 2

3 2 Not Found

When x=9

Low high mid

1 14 7

1 6 3

4 6 5- found

CSE@HKBKCE 4 2017-18

DAA Module-2

Proof: We assume that all statements work as expected and that comparisons such as x > a[mid] are

appropriately carried out.

Initially low = 1,high = n, n > 0, and a[1] < a[2] < • • • < a[n].

If n = 0, the while loop is not entered and 0 is returned.

Otherwise we observe that each time through the loop the possible elements to be checked for equality

with x are a[low],a[low + 1], . . ., a[mid], ..., a[high]. If x = a[mid], then the algorithm terminates

successfully. Otherwise the range is narrowed by either increasing low to mid + 1 or decreasing high to

mid - 1. Clearly this narrowing of the range does not affect the outcome of the search. If low becomes

greater than high, then x is not present and hence the loop is exited.

To fully test binary search, we need not consider the values of a[1 : n]. By varying x sufficiently, we

can observe all possible computation sequences of BinSearch without devising different values for a. To

test all successful searches, x must take on the n values in a. To test all unsuccessful searches, x need

only take on n + 1 different values. Thus the complexity of testing BinSearch is 2n + 1

Space complexity analysis: storage is required for the n elements of the array plus the variables low,

high, mid, and x, therefore the space requirement is n + 4 locations

The basic operation of this algorithm is the element comparison that is the comparisons between x and

the elements in a[ ]. We assume that only one comparison is needed to determine which of the three

possibilities of the “if” statement holds.

The number of element comparisons needed to find each of the 14 elements is given below. No element

requires more than 4 comparisons to be found.

Index [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]

element -15 -6 0 7 9 23 54 82 101 112 125 131 142 151

comparisons 3 4 2 4 3 4 1 4 3 4 2 4 3 4

To derive a formula for time complexity consider the sequence of values for mid that are produced by

BinSearch for all possible values of x. These values can be described using a binary decision tree . Here

the value of each node is the value of mid. For example, if n = 14, then Figure 2.1 contains a binary

decision tree that traces the way in which the sequence of mid values are produced by BinSearch

CSE@HKBKCE 5 2017-18

DAA Module-2

The first comparison is x with a[7]. If x < a[7], then the next comparison is with a[3], similarly, if x >

a[7], then the next comparison is with a[11]. Each path through the tree represents a sequence of

comparisons in the binary search method. If x is present, then the algorithm will end at one of the

circular nodes that list the index into the array where x was found. If x is not present, the algorithm will

terminate at one of the square nodes. Circular nodes are called internal nodes, and square nodes are

referred to as external nodes.

Theorem: If n is in the range [2k-1, 2k ), then BinSearch makes at most k element comparisons for a

successful search and either k -1 or k comparisons for an unsuccessful search. i.e.. the time for a

successful search is 0(1og n) and for an unsuccessful search is (log n)).

Proof: Consider the binary decision tree describing the action of BinSearch on n elements. All

successful searches end at a circular node whereas all unsuccessful searches end at a square node. If 2k-1

n < 2k , then all circular nodes are at levels 1, 2, ... , k whereas all square nodes are at levels k and k +

1 (note that the root is at level 1). The number of element comparisons needed to terminate at a circular

node on level i is i whereas the number of element comparisons needed to terminate at a square node at

level i is only i- 1. Therefore the theorem is proved.

To determine the average behavior, size needs to be equated to the number of element comparisons

in the algorithm. The distance of a node from the root is one less than its level. The internal path length I

is the sum of the distances of all internal nodes from the root. Analogously, the external path length E is

the sum of the distances of all external nodes from the root. For any binary tree with n internal nodes, E

and I are related by the formula.

E=I+2n

Let As(n) be the average number of comparisons in a successful search, and Au(n) the average number of

comparisons in an unsuccessful search.

The number of comparisons needed to find an element represented by an internal node is one more than

the distance of this node from the root. Hence,

CSE@HKBKCE 6 2017-18

DAA Module-2

AS (n) = 1 + I /n

The number of comparisons on any path from the root to an external node is equal to the distance

between the root and the external node. Since every binary tree with n internal nodes has n + 1 external

nodes, it follows that

Au(n) = E / (n + 1)

Using these three formulas for E, As (n) , and Au(n), we find that

As(n) = (1 + 1/n)Au(n) -1

From this formula we see that As(n) and Au(n) are directly related. The minimum value of As(n) (and

hence Au(n)) is achieved by an algorithm whose binary decision tree has minimum external and internal

path length. This minimum is achieved by the binary tree all of whose external nodes are on adjacent

levels, and this is the tree that is produced by binary search algorithm. It follows that E is proportional to

n log n. Using this in the preceding formulas, we conclude that As(n) and Au(n) are both proportional to

log n. Thus we conclude that the average- and worst-case numbers of comparisons for binary search are

the same , within a constant factor.

For a successful search only one element comparison is needed. For an unsuccessful search, [logn]

element comparisons are needed in the best case.

Therefore the formulas that describe the time complexity of the algorithm in the best average and worst

cases are:

The problem is to find the maximum and minimum items in a set of n elements.

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

3{

4 max := min := a[1];

5 for i := 2 to n do

6 {

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

8 if (a[i] < min) then min := a[i];

9 }

10}

CSE@HKBKCE 7 2017-18

DAA Module-2

The time complexity of this algorithm is determined by the number of element comparisons. The

justification for this is that the frequency count for other operations in this algorithm is of the same order

as that for element comparisons.

(n-1) comparisons are needed to find the max element and (n-1) comparisons to find the min element.

Therefore, Algorithm StraightMaxMin requires 2(n - 1) element comparisons in the best, average, and

worst cases.

Improvement

The comparison a[i] < min is necessary only when a[i] > max is false. Hence we can replace the

contents of the for loop by

else if (a[i] < min) then min := a[i];

Now the best case occurs when the elements are in increasing order. The number of element

comparisons is n — 1. The worst case occurs when the elements are in decreasing order. In this case the

number of element comparisons is 2(n — 1). The average number of element comparisons is less than 2(n

— 1). On the average, a[i] is greater than max half the time, and so the average number of comparisons is

3(n/2 — 1)

Let P = (n, a[i], , a[j]) denote an arbitrary instance of the problem. Here n is the number of elements in

the list a[i], , a[j] and we are interested in finding the maximum and minimum of this list. Let Small(P)

be true when n < 2. In this case, the maximum and minimum are a[i] if n = 1. If n = 2, the problem can

be solved by making one comparison.

If the list has more than two elements, P has to be divided into smaller instances. For example, we might

divide P into the two instances P1 = ([n/2] , a[1], , a[[n/2]]) and P2 = (n- [n/2] ,a[[n/2] + 1], ... ,a[n]).

After having divided P into two smaller sub problems, we can solve them by recursively invoking the

same divide-and-conquer algorithm.

To combine p1 and p2 If MAX(P) and MIN(P) are the maximum and minimum of the elements in P,

then MAX(P) is the larger of MAX(P1 ) and MAX(P2). Also, MIN(P) is the smaller of MIN(P1 ) and

MIN(P2).

Recursive solution for maximum and minimum that is implemented using divide and conquer technique.

1 Algorithm MaxMin(i, j , max, min)

2// a[1 : n] is a global array. Parameters i and j are integers,

3 // 1 < i < j < n. The effect is to set max and min to the

4 // largest and smallest values in a[i : j], respectively.

5{

6 if (i = j) then max := min := a[i]; // Small(P)

7 else if (i = j — 1) then // Another case of Small(P)

CSE@HKBKCE 8 2017-18

DAA Module-2

8{

9 if (a[i] < a[j]) then

10 {

11 max := a[j]; Min : = a[i];

12 }

13 else

{

15 max := a[i]; min := a[j];

16 }

17 }

18 else

19 { // If P is not small, divide P into subproblems.

2l // Find where to split the set.

21 mid := [(i + j)/2];

22 // Solve the subproblems.

23 MaxMin(i, mid, max, min);

2: MaxMin(mid+ 1, j,maxl,min1);

25 // Combine the solutions.

26 if (max < max1) then max := maxi;

27 if (min > minl) then min := minl;

28 }

29 }

CSE@HKBKCE 9 2017-18

DAA Module-2

Recurrence relation is

T(n) =2T(n/2) +2 Substituting n= 2k

k-1

=2*T(2 ) +2

=2[2*T(2k-2 )+2] +2 = 22*T(2k-2 ) + 22 + 2

= 22*[2*T(2k-3 ) + 2]+ 22 + 2 =23*T(2k-3 ) + 23+ 22 + 2

Substituting i=k-1 = 2k-1*T(2k-k +1 ) + 2k-1+ 2k-2 +…….. 21

= 2k-1 *T(2)+ 2k-1 +…….. 21

= 2k-1 + 2k -2 = 2k (1/2 + 1) -2 = 3/2*2 log 2n -2= 3n/2 -2

T(n) (n)

Note that 3n/2 - 2 is the best-, average-, and worst-case number of comparisons when n is a power of

two. Compared with the 2n - 2 comparisons for the straightforward method, this is a saving of 25% in

comparisons.

In terms of storage, MaxMin is worse than the straightforward algorithm because it requires stack space

for i, j, max, min,max1,min1 and the return address. So Given n elements, there will be [log n] +1 levels

2

of recursion and we need to save seven values for each recursive call

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],

sorting each of them recursively, and then merging the two smaller sorted arrays into a single sorted one.

{

//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]

Mergesort(B[0.._n/2 − 1])

Mergesort(C[0.._n/2 − 1])

Merge(B, C, A)

}

}

CSE@HKBKCE 10 2017-18

DAA Module-2

//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]

Example:

Simulation of merge sort for the list 8, 3, 2, 9, 7, 1, 5, 4

Input size is n

Assuming that n is a power of 2, the recurrence relation for the number of key comparisons C(n) is

C(n) = 2C(n/2) + Cmerge(n) for n > 1, C(1) = 0.

CSE@HKBKCE 11 2017-18

DAA Module-2

Analysis of Cmerge(n)

The number of key comparisons performed during the merging stage. At each step, exactly one

comparison is made, after which the total number of elements in the two arrays still needing to be

processed is reduced by 1. In the worst case, neither of the two arrays becomes empty before the other

one contains just one element (e.g., smaller elements may come from the alternating arrays). Therefore,

for the worst case, Cmerge(n) = n – 1.

The principal shortcoming of mergesort is the linear amount of extra storage the algorithm requires.

Quick sort is a sorting algorithm that is based on the divide-and conquer approach. Quick sort

divides its input element according to their value.

Partition - array elements are arranged so that all the elements to the left of some element A[s] are

less than or equal to A[s], and all the elements to the right of A[s] are greater than or equal to it

therefore after the partition A[s] will be in its final position in the sorted array. Now the two sub

arrays to the left and to the right of A[s] can be sorted independently. Combining the sub problem is

not required

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])

}

Partition algorithm

Partition starts by selecting a pivot.

CSE@HKBKCE 12 2017-18

DAA Module-2

The first element of the sub array is treated as the pivot p=A[l].

Now scan the sub array from both ends, comparing the elements to the pivot.

The left-to-right scan, denoted below by index pointer i, starts with the second element. Since we

want elements smaller than the pivot to be in the left part of the sub array, this scan skips over

elements that are smaller than the pivot and stops upon encountering the first element greater

than or equal to the pivot.

The right-to-left scan, denoted below by index pointer j, starts with the last element of the sub

array. Since we want elements larger than the pivot to be in the right part of the sub array, this

scan skips over elements that are larger than the pivot and stops on encountering the first element

smaller than or equal to the pivot.

After both scans stop, three situations may arise, depending on whether or not the scanning indices have

crossed.

1. If i < j, exchange A[i] and A[j ] and resume the scans by incrementing i and decrementing j,

respectively.

2. If , i > j, The sub array is partitioned after exchanging the pivot with A[j ].

3. If 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 :

We can combine the last case with the case of crossed-over indices (i > j ) by exchanging the pivot with

A[j ] whenever i ≥ j .

ALGORITHM HoarePartition(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+1; j ←r

while(i<=j)

{

while(A[i]<=p) i=i+1

while(A[j] >p) j=j-1

swap(A[i], A[j ]) //undo last swap when i ≥ j

}

swap(A[l], A[j ])

return j }

CSE@HKBKCE 13 2017-18

DAA Module-2

Note : Index i can go out of the sub array’s bounds in this pseudocode. Rather than checking for this

possibility every time index i is incremented, we can append to arrayA[0..n − 1]a “sentinel” that would

prevent index i from advancing beyond position n

.

The number of key comparisons made before a partition is achieved is n + 1 if the scanning indices cross

over and coincide n If all the splits happen in the middle of corresponding sub arrays, we will have the

best case. The number of key comparisons in the best case satisfies the recurrence

According to the Master Theorem, Cbest(n) ∈ (n log2 n); solving it exactly for n = 2k yields

Cbest(n) = n log2 n.

CSE@HKBKCE 14 2017-18

DAA Module-2

In the worst case, all the splits will be skewed to the extreme: one of the two subarrays will be empty,

and the size of the other will be just 1 less than the size of the sub array being partitioned. This

unfortunate situation will happen, in particular, for increasing arrays, i.e., for inputs for which the

problem is already solved. Indeed, 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] while the right-to-left scan will go all the way to reach

A[0], indicating the split at position 0:

So, after making n + 1 comparisons to get to this partition and exchanging the pivot A[0] with itself, the

algorithm will be left with the strictly increasing array A[1..n − 1] to sort. This sorting of strictly

increasing arrays of diminishing sizes will continue until the last one A[n − 2..n − 1] has been processed.

The total number of key comparisons made will be equal to

Partition can happen in any position s (0 ≤ s ≤ n−1) after n+1comparisons are made to achieve the

partition. After the partition, the left and right sub arrays will have s and n − 1− s elements,

respectively. Assuming that the partition split can happen in each position s with the same probability

1/n, we get the following recurrence relation:

Solution:

Thus, on the average, quick sort makes only 39% more comparisons than in the best case. Moreover, its

innermost loop is so efficient that it usually runs faster than merge sort on randomly ordered arrays of

nontrivial sizes. This certainly justifies the name given to the algorithm by its inventor.

Weakness

It is not stable.

It requires a stack to store parameters of sub arrays that are yet to be sorted.

Although more sophisticated ways of choosing a pivot make the quadratic running time of the

worst case very unlikely, they do not eliminate it completely.

CSE@HKBKCE 15 2017-18

DAA Module-2

Merge sort Quick sort

Divides its input elements according to their Divides its input element according to their

position in the array. value.

Division of the problem into two sub problems is The entire work happens in the division stage,

immediate and the entire work happens in with no work required to combine the solutions

combining their solutions to the sub problems.

Let A and B be two n X n, matrices. The product matrix C = AB is also an n X n matrix whose i, jth

element is formed by taking the elements in the ith row of A and the jth column of B and multiplying

them to get

for all i and j between 1 and n. To compute C(i, j) using this formula, we need n multiplications. As

the matrix C has n2 elements, the time for the resulting matrix multiplication algorithm, which we

refer to as the conventional method is (n3).

Divide and conquer strategy to compute the product of two nXn matrix

we assume that n is a power of 2, that is, that there exists a nonnegative integer k such that n = 2k . In

case n, is not a power of two, then enough rows and columns of zeros can be added to both A and B so

that the resulting dimensions are a power of two.

Imagine that A and B are each partitioned into four square sub matrices, each sub matrix having

dimensions n/2x n/2. Then the product AB can be computed by using the above formula in equation 2.1

for the product of 2 x 2 matrices.

If AB is

----------- 2.2

For n=2 the elements of C can be computed directly using formula 2.2 the For n >2, the elements of C

can be computed using 8 matrix multiplication and 4 addition operations applied to matrices of size

n/2 x n/2. Since n is a power of 2, these matrix products can be recursively computed by the same

CSE@HKBKCE 16 2017-18

DAA Module-2

algorithm we are using for the n x n case. This algorithm will continue applying itself to smaller-sized

sub matrices until n becomes suitably small (n = 2) so that the product is computed directly. Since two

n/2 x n/2 matrices can be added in time cn2 for some constant c, the overall computing time T(n) of the

resulting divide-and-conquer algorithm is given by the recurrence

The recurrence can be solved to obtain T(n)= O(n3). Hence no improvement over the conventional

method has been made.

Since matrix multiplications are more expensive than matrix additions (0(n3) versus 0(n2)), we can

attempt to reformulate the equations for Cij so as to have fewer multiplications and possibly more

additions. Volker Strassen has discovered a way to compute the Cij 's of (2.2) using only 7

multiplications and 18 additions or subtractions as given in the formula of 2.3 and 2.4

----------- 2.3

----------- 2.4

Where a and b are constants. Solving the recurrence using masters theorem we get

Advantages

1. Here a problem is divided into sub problems and each sub problem is solved independently and

therefore it is a good approach to solve difficult problem.

2. Divide-and-conquer technique is probably the best-known general algorithm design technique.

3. Facilitates the discovery of efficient algorithm

4. Sub problems can be executed on parallel processors to solve the problem faster.

Disadvantage

1. Large numbers of sub lists are created and need to be processed.

2. Makes use of recursive methods. Recursive methods are slow and require stack space for

each recursive call.

CSE@HKBKCE 17 2017-18

DAA Module-2

The decrease-and-conquer technique is based on

Exploiting the relationship between a solution to a given instance of a problem and a solution

to its smaller instance.

Once such a relationship is established, it can be solved either top down(recursive )or bottom

up(Iterative) .

The bottom-up variation is usually implemented iteratively, starting with a solution to the smallest

instance of the problem; it is called sometimes the incremental approach.

Decrease by a constant

Decrease by a constant factor

Variable size decrease

The size of an instance is reduced by the same constant, on each iteration of the algorithm.

Typically, this constant is equal to one (Figure 2.5). The recursive relation can be represented as.

CSE@HKBKCE 18 2017-18

DAA Module-2

Example: consider the exponentiation problem of computing an where a≠0 and n is a nonnegative

integer. The relationship between a solution to an instance of size n and an instance of size n − 1 is

obtained by the formula an = an−1 *a. So the function f (n) = an can be computed either “top down”

by using its recursive definition or “bottom up” by multiplying a n times. The formula is

Example: a5=a4*a

Reducing a problem instance by the same constant factor on each iteration of the algorithm. In most

applications, this constant factor is equal to two.

quer technique

Example: consider the exponentiation problem If the instance of size n is to compute an, the instance of

half its size is to compute an/2, with the relationship between the two: an = (an/2)2. But since we consider

instances with integer exponents only . If n is odd, we have to compute a n−1 by using the rule for even-

valued exponents and then multiply the result by a. To summarize, we have the following formula

CSE@HKBKCE 19 2017-18

DAA Module-2

If we compute an recursively according to formula then the time complexity T(n) is (log n)

The size-reduction pattern varies from one iteration of an algorithm to another.Example: Euclid’s

algorithm for computing the greatest common divisor

gcd(m, n) = gcd(n, m mod n).

Though the value of the second argument is always smaller on the right-hand side than on the left-hand

side, it decreases neither by a constant nor by a constant factor.

Topological sorting is a problem of directed graph that has application in pre- requisite restricted

tasks.

A directed graph, or digraph for short, is a graph with directions specified for all its edges.

The adjacency matrix and adjacency lists are two principal means of representing a digraph.

Depth-first search and breadth-first search are principal traversal algorithms for traversing

digraphs.

Four types of edges possible in a DFS forestof a directed graph (figure 2.7a) are (Figure 2.7b)

tree edges (ab, bc, de), back edges (ba) from vertices to their ancestors, forward edges (ac) from

vertices to their descendants in the tree other than their children, and cross edges (dc).

FIGURE 2.7 (a) Digraph. (b) DFS forest of the digraph for the DFS traversal started at a.

Example :

Consider a set of five required courses {C1, C2, C3, C4, C5} a part-time student has to take in some

degree program. The courses can be taken in any order as long as the following course prerequisites are

met: C1 and C2 have no prerequisites, C3 requires C1 and C2, C4 requires C3, and C5 requires C3 and

C4. The student can take only one course per term. In which order should the student take the courses?

CSE@HKBKCE 20 2017-18

DAA Module-2

y a digraph in which vertices represent courses and directed edges indicate prerequisite requirements as

shown in figure 2.8

If the vertices of a graph are listed in such an order that for every edge in the graph, the vertex where the

edge starts is listed before the vertex where the edge ends is the problem of topological sorting. Thus,

for topological sorting to be possible, a digraph in question must be a DAG( directed acyclic graph)

There are two efficient algorithms that both verify whether a digraph is a dag and, if it produce an

ordering of vertices that solves the topological sorting problem

Perform a DFS traversal and note the order in which vertices become dead-ends (i.e., popped off the

traversal stack). Reversing this order yields a solution to the topological sorting problem. No back edge

should have been encountered during the traversal. If a back edge has been encountered, the digraph is

not a dag, and topological sorting of its vertices is impossible.

Figure 2.9 a) digraph b) DFS traversal stack with the subscript numbers indicating the popping off order

(c) Solution to the problem.

Direct implementation of the decrease-(by one)-and-conquer technique

Repeatedly, identify in a remaining digraph a source, which is a vertex with no incoming edges, and

delete it along with all the edges outgoing from it. (If there are several sources, break the tie arbitrarily.

If there are none, stop because the problem cannot be solved. The order in which the vertices are deleted

yields a solution to the topological sorting problem. The application of this algorithm to the same

digraph representing the five courses is given in Figure 2.10.

CSE@HKBKCE 21 2017-18

DAA Module-2

Instruction scheduling in program compilation,

Cell evaluation ordering in spreadsheet

Formulas and resolving symbol dependencies in linkers.

CSE@HKBKCE 22 2017-18

- java programming II Final Exam Study SheetsTransféré partomritch
- Important Problem TypesTransféré parSahila Devi
- DFS and BFS algorithmTransféré parRohan Chavan
- Quick SortTransféré parSnehal
- DS Model Paper 2013 14Transféré parRK Sanayaima Singh
- Gondwana Univ - CAD-CAMTransféré parhari
- HCL Commonly Asked Questions 2Transféré parShabin Crzyracer
- RA17M1B39_Homework 1_CSE408_algorollno39Transféré pargirijesh89
- IJAIEM-2013-09-18-030.pdfTransféré parAnonymous vQrJlEN
- AITransféré parमेनसन लाखेमरू
- 8.0 Environment VariablesTransféré parPradeep Kumar
- PIC10B_lecture14Transféré parazasteel
- algorithm - Counting inversions in an array - Stack Overflow.htm.txtTransféré parprasuresh
- Array.pdfTransféré parVanessa Johnson
- cloveretlclusterexplained-130814083119-phpapp01Transféré parVijay Kumar
- Lecture 02Transféré parprachi
- Design analysis of algosTransféré parjayasimhareddy
- Resource LevelingTransféré parMarcos Andres Crespo Monroy
- Divide and ConquerTransféré parM Duraipandian Mariappan
- Introduction to the Design and Analysis of Algorithms - Lecture Notes, Study Material and Important Questions, AnswersTransféré parM.V. TV
- Chen 2016Transféré parranjini
- booklet.pdfTransféré parFarid Adilazuarda

- Recent Advances in Robust Control - Theory and Applications in Robotics and ElectromechanicsTransféré parcemoksz
- Ibhm 086-107 PolinomialTransféré paroke
- FXSkew2Transféré parharelj1
- WS_HMatricesTransféré parinsomniacsh
- Generalized CoordinatesTransféré parJoshua Wood
- pertusaphdTransféré paratom tux
- Ph.D. Information Brochure-roorkeeTransféré parPrashant Chopdar
- Face Recognition using Face Alignment and PCA Techniques: A Literature SurveyTransféré parIOSRjournal
- Optimization Nonlinear-OttoTransféré parAza Lg
- 01.Algorithms and Complexity 2008Transféré parIgor Stojkov
- mathprogTransféré parZhuo Liu
- Accurate ComputingTransféré parRm1262
- Integrated Speed Limit Detection and RecognitionTransféré paryash1239
- A Dominance-based Rough Set Approach to Kansei EngineeringTransféré parvbeauboi
- Big-O Algorithm Complexity Cheat SheetTransféré parPravind Kumar
- 03pmn_2014Transféré parI Gede Tirtanata
- 1-s2.0-S0305054815003032-mainTransféré parAida Ulfa Faza
- Water JugsTransféré parnirmala_baloorkar5693
- 1.- WLAR-Viz Weighted Least Association RulesTransféré parcristian_master
- Timing AttackTransféré parVaishali Jain
- Sys Id ToolkitTransféré parDavidleonardo Galindo
- key encoding messages into matricesTransféré parapi-327831432
- Moore and Mealy MachinesTransféré parNirmal Kumar Pandey
- graphing quadratic functions study gruideTransféré parapi-263670707
- Domain Name System(DNS)Transféré parPikesh Patel
- Grade 12 Data Management NotesTransféré parkayj09
- week7.pdfTransféré parKurt Mk-Jim
- Linear Inequations 3Transféré parDebasis Saha
- 4848853.pptTransféré parMaz Har Ul
- Chapter 05 SlidesTransféré parbebo7usa

## Bien plus que des documents.