ALGORITHM DESIGN TECHNIQUES

WHAT IS ALGORITHM DESIGN?

Algorithm Design is a specific method to create mathematical process in solving various classical problems, real world complex problems. Techniques for designing and implementing algorithm design are design patterns.

ALGORITHM DESIGN TECHNIQUES

We have 5 base techniques that can be used to design any algorithm. 

1. Divide and Conquer
2. Greedy Method
3. Dynamic Programming
4. Back Tracking
5. Branch and Bound

WHAT IS DIVIDE AND CONQUER TECHNIQUE? 

In branch and bound technique, we break the main problem into several sub-problems. Sub-problems are similar to original problem but smaller in size. To solve given problem algorithm call themselves to deal with subproblems. Once subproblems are solved recursively then combine these solutions to create a final solution for the original problem. Merge Sort Algorithm follow Divide and Conquer method.

Step 01: Divide the main problem into subproblems [n/2].

Step 02: Solve the subproblems recursively. 

Step 03: Combine the solutions to subproblems into the final solution for original problem.

NUMERICAL EXAMPLE: APPLY DIVIDE AND CONQUER TECHNIQUE TO SORT A SEQUENCE AND PRODUCE THE SORTED ANSWER.

Suppose, Array to be Sorted

STEP 01: Divide the Main Problem into Sub-Problems.

Let P, q, r = Indices Numbering sequence of the array.  

P = 1, q = 4, r = 8

(n1) Sub-Problem 01: A[P,...,q].

 n1 = q - p + 1 = 4 - 1 + 1 = 4

(n2) Sub-Problem 02: A[q+1,...,r].

 n2 = r - q = 8 - 4 = 4 

STEP 02: Create Array L[] and R[].

For i = 1: n1          

   Do L[i] = P + i -1

           L [1] = 1+1-1=1 ; 

           L[2] = 1+2-1=2; 

           L[3] = 1+3-1 = 3; 

           L[4] = 1+4-1 = 4

 Array Elements:   L[ 5    6    9    10 ] 

For j = 1 to n2

  Do R[j] = q + j

         R[1] = 4+1=5;

         R[2] = 4+2= 6;

         R[3] = 4+3= 7;

         R[4] = 4+4 = 8;

Array Elements:   R[ 1    2   4   20]

Now, Main problem is break down into 2 sub-problems L[ 5    6    9    10 ]  and R[ 1    2   4   20]. Now we will solve subproblems then in the end combine the solution. 

Let i = 1; and j = 1;

For G = P to r

 Do if L[i] <= R[j] 

then A[G] - L[i]

  i = i+1;

Else

  A[G] - R[j]

  j = j + L;

Final Output After several recursions.