CHAPTER 1

1. REVIEW
1.1. Concept of algorithm

A common man’s belief is that a computer can do anything and everything that he
imagines. It is very difficult to make people realize that it is not really the computer but
the man behind computer who does everything.
In the modern internet world man feels that just by entering what he wants to search into
the computers he can get information as desired by him. He believes that, this is done by
computer. A common man seldom understands that a man made procedure called search
has done the entire job and the only support provided by the computer is the executional
speed and organized storage of information.
In the above instance, a designer of the information system should know what one
frequently searches for. He should make a structured organization of all those details to
store in memory of the computer. Based on the requirement, the right information is
brought out. This is accomplished through a set of instructions created by the designer of
the information system to search the right information matching the requirement of the
user. This set of instructions is termed as program. It should be evident by now that it is
not the computer, which generates automatically the program but it is the designer of the
information system who has created this.
Thus, the program is the one, which through the medium of the computer executes to
perform all the activities as desired by a user. This implies that programming a computer
is more important than the computer itself while solving a problem using a computer and
this part of programming has got to be done by the man behind the computer. Even at this
stage, one should not quickly jump to a conclusion that coding is programming. Coding is
perhaps the last stage in the process of programming. Programming involves various
activities form the stage of conceiving the problem upto the stage of creating a model to
solve the problem. The formal representation of this model as a sequence of instructions
is called an algorithm and coded algorithm in a specific computer language is called a
program.

School of computing and Informatics Computer Science Gutema S.

One can now experience that the focus is shifted from computer to computer
programming and then to creating an algorithm. This is algorithm design, heart of
problem solving.
1.2. Characteristics of an algorithm
Scenario one
Let us try to present the scenario of a man brushing his own teeth(natural denture) as an
algorithm as follows.
Step 1. Take the brush
Step 2. Apply the paste
Step 3. Start brushing
Step 4. Rinse
Step 5. Wash
Step 6. Stop
If one goes through these 6 steps without being aware of the statement of the problem, he
could possibly feel that this is the algorithm for cleaning a toilet. This is because of
several ambiguities while comprehending every step. The step 1 may imply tooth brush,
paint brush, toilet brush etc. Such an ambiguity doesn’t an instruction an algorithmic step.
Thus every step should be made unambiguous. An unambiguous step is called definite
instruction. Even if the step 2 is rewritten as apply the tooth paste, to eliminate
ambiguities yet the conflicts such as, where to apply the tooth paste and where is the
source of the tooth paste, need to be resolved. Hence, the act of applying the toothpaste is
not mentioned. Although unambiguous, such unrealizable steps can’t be included as
algorithmic instruction as they are not effective.
The definiteness and effectiveness of an instruction implies the successful termination of
that instruction. However the above two may not be sufficient to guarantee the
termination of the algorithm. Therefore, while designing an algorithm care should be
taken to provide a proper termination for algorithm.

School of computing and Informatics Computer Science Gutema S.

Scenario two
Task: to make a cup of tea.

Algorithm:

1. add water and milk to the kettle,

2. boil it, add tea leaves,

3. Add sugar, and then serve it in cup.

What is Computer algorithm?

‘’a set of steps to accomplish or complete a task that is described precisely enough that a
computer can run it’’.

Described precisely: very difficult for a machine to know how much water, milk to be
added etc. in the above tea making algorithm.

These algorithms run on computers or computational devices. For example, GPS in our
smartphones, Google hangouts. GPS uses shortest path algorithm. Online shopping uses
cryptography which uses RSA algorithm.

Thus, every algorithm should have the following five characteristic features
1. Input
2. Output
3. Definiteness
4. Effectiveness
5. Termination
Therefore, an algorithm can be defined as a sequence of definite and effective
instructions, which terminates with the production of correct output from the given input.
In other words, viewed little more formally, an algorithm is a step by step formalization
of a mapping function to map input set onto an output set.
The problem of writing down the correct algorithm for the above problem of brushing the
teeth is left to the reader.
For the purpose of clarity in understanding, let us consider the following examples.
Example 1:
Problem : finding the largest value among n>=1 numbers.
Input : the value of n and n numbers

School of computing and Informatics Computer Science Gutema S.

Output : the largest value
Steps :
1. Let the value of the first be the largest value denoted by BIG
2. Let R denote the number of remaining numbers. R=n-1
3. If R != 0 then it is implied that the list is still not exhausted. Therefore
look the next number called NEW.
4. Now R becomes R-1
5. If NEW is greater than BIG then replace BIG by the value of NEW
6. Repeat steps 3 to 5 until R becomes zero.
7. Print BIG
8. Stop
End of algorithm
Example 2: quadratic equation
Example 3: listing all prime numbers between two limits n1 and n2.
1.2.1 Algorithmic Notations
In this section we present the pseudocode that we use through out the book to describe
algorithms. The pseudo code used resembles PASCAL and C language control structures.
Hence, it is expected that the reader be aware of PASCAL/C. Even otherwise atleast now
it is required that the reader should know preferably C to practically test the algorithm in
this course work.
However, for the sake of completion we present the commonly employed control
constructs present in the algorithms.
2. A conditional statement has the following form
If < condition> then
Block 1
Else
Block 2
If end.
This pseudocode executes block1 if the condition is true otherwise block2 is executed.

3. The two types of loop structures are counter based and conditional based and they are
as follows

School of computing and Informatics Computer Science Gutema S.

  For variable = value1 to value2 do
Block
For end
Here the block is executed for all the values of the variable from value 1 to value 2.
 There are two types of conditional looping, while type and repeat type.

While (condition) do
Block
While end.
Here block gets executed as long as the condition is true.

 Repeat
Block
Until<condition>
Here block is executed as long as condition is false. It may be observed that the block is
executed atleast once in repeat type.
Exercise 1;
Devise the algorithm for the following and verify whether they satisfy all the features.
1. An algorithm that inputs three numbers and outputs them in ascending order.
2. To test whether the three numbers represent the sides of a right angle triangle.
3. To test whether a given point p(x,y) lies on x-axis or y-axis or in I/II/III/IV quadrant.
4. To compute the area of a circle of a given circumference
5. To locate a specific word in a dictionary.
Note : it is always required to hand simulate with suitable input dataset.

School of computing and Informatics Computer Science Gutema S.

 CHAPTER 2
2. Different Perspective of Algorithms
If there are more then one possible way of solving a problem, then one may think of more
than one algorithm for the same problem. Hence, it is necessary to know in what domains
these algorithms are applicable. Data domain is an important aspect to be known in the
field of algorithms. Once we have more than one algorithm for a given problem, how do
we choose the best among them? The solution is to devise some data sets and determine a
performance profile for each of the algorithms. A best case data set can be obtained by
having all distinct data in the set. But, it is always complex to determine a data set, which
exhibits some average behavior. The following sections give a brief idea of the well-
known accepted algorithms.
2.1 Numerical Algorithms
Numerical analysis is the theory of constructive methods in mathematical analysis.
Constructive method is a procedure used to obtain the solution for a mathematical
problem in finite number of steps and to some desired accuracy.
2.1.1 Numerical Iterative Algorithm
An iterative process can be illustrated with the flow chart given in fig 2.1. There are four
main blocks in the process viz., initialization, decision, computation, and update. The
functions of these four blocks are as follows:
1. Initialization: all parameters are set to their initial values.
2. Decision: decision parameter is used to determine when to exit from the loop.
3. Computation: required computation is performed.
4. Update: decision parameter is updated and is transformed for next iteration.
Many problems in engineering or science need the solution of simultaneous linear
algebraic equations. Every iterative algorithm is infinite step algorithm. One of the
iterative algorithms to solve system of simultaneous equations is Guass Siedel. This
iteration method requires generally a few iteration. Iterative techniques have less round-
off error. For large system of equations, the iteration required may be quite large. But,
there is a guarantee of getting the convergent result.
For example: consider the following set of equations,
10x1+2x2+x3= 9
2x1+20x2-2x3= -44

School of computing and Informatics Computer Science Gutema S.

 -2x1+3x2+10x3= 22.
To solve the above set of equations using Guass Siedel iteration scheme, start with
(x1(1),x2(1),x3(1))=(0,0,0) as initial values and compute the values of we write the system of
x1, x2, x3 using the equations given below
x1(k+1)=(b1-a12x2(k+1)-a13x3(k))/a11
x2(k+1)=(b2-a21x1(k+1)-a23x3(k))/a22
x3(k+1)=(b3-a31x1(k+1)-a32x3(k+1))/a33

for k=1,2,3,…
This process is continued upto some desired accuracy. Numerical iterative methods are
also applicable for obtaining the roots of the equation of the form f(x)=0. The various

Figure 0:1 flowchart for iterative process

iterative methods used for this purpose are,

1. Bisection method: xi+2=(xi+xi+1)/2

2. Regula- Falsi method: x2=(x0f(x1)+ x1f(x0))/ (f(x1)-f(x0))
3. Newton Raphson method: x2= x1-f(x1)/f1(x1)

School of computing and Informatics Computer Science Gutema S.

2.2 Searching
Let us assume that we have a sequential file and we wish to retrieve an element matching
with key ‘k’, then, we have to search the entire file from the beginning till the end to
check whether the element matching k is present in the file or not.
There are a number of complex searching algorithms to serve the purpose of searching.
The linear search and binary search methods are relatively straight forward methods of
searching.
2.2.1 Sequential search

In this method, we start to search from the beginning of the list and examine each
element till the end of the list. If the desired element is found we stop the search and
return the index of that element. If the item is not found and the list is exhausted the
search returns a zero value.
In the worst case the item is not found or the search item is the last (nth) element. For both
situations we must examine all n elements of the array so the order of magnitude or
complexity of the sequential search is n. i.e., O(n). The execution time for this algorithm
is proportional to n that is the algorithm executes in linear time.

The algorithm for sequential search is as follows,

Algorithm : sequential search
Input : A, vector of n elements
K, search element
Output : j –index of k
Method : i=1
While(i<=n)
{
if(A[i]=k)
{
write(“search successful”)
write(k is at location i)
exit();
}

School of computing and Informatics Computer Science Gutema S.

 else
i++
if end
while end
write (search unsuccessful);
algorithm ends.
2.2.2 Binary search
Binary search method is also relatively simple method. For this method it is necessary to
have the vector in an alphabetical or numerically increasing order. Binary Search is
defined as a searching algorithm used in a sorted array by repeatedly dividing the search
interval in half. The idea of binary search is to use the information that the array is sorted
and reduce the time complexity to O(log N).
A search for a particular item with X resembles the search for a word in the dictionary.
The approximate mid entry is located and its key value is examined. If the mid value is
greater than X, then the list is chopped off at the (mid-1)th location. Now the list gets
reduced to half the original list. The middle entry of the left-reduced list is examined in a
similar manner. This procedure is repeated until the item is found or the list has no more
elements. On the other hand, if the mid value is lesser than X, then the list is chopped off
at (mid+1)th location. The middle entry of the right-reduced list is examined and the
procedure is continued until desired key is found or the search interval is exhausted.

School of computing and Informatics Computer Science Gutema S.

 Figure 0:2 Example of Binary Search Algorithm
Conditions for when to apply Binary Search in a Data Structure:
To apply Binary Search algorithm:
 The data structure must be sorted.
 Access to any element of the data structure takes constant time.
The algorithm for binary search is as follows,

Figure 0:3 Finding the middle index “mid” in Binary Search Algorithm
Compare the middle element of the search space with the key.
1. If the key is found at middle element, the process is terminated.
2. If the key is not found at middle element, choose which half will be used as the
next search space.
3. If the key is smaller than the middle element, then the left side is used for next
search.
4. If the key is larger than the middle element, then the right side is used for next
search.
5. This process is continued until the key is found or the total search space is
exhausted.
Algorithm : binary search
Input : A, vector of n elements
K, search element
Output : low –index of k
Method : low=1,high=n
While(low<=high-1)
{
mid=(low+high)/2
if(k<a[mid])
high=mid

School of computing and Informatics Computer Science Gutema S.

 else
low=mid
if end
}
while end
if(k=A[low])
{
write(“search successful”)
write(k is at location low)
exit();

}
else
write (search unsuccessful);
if end;
algorithm ends.
Example
Consider an array arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}, and the target = 23.
First Step: Calculate the mid and compare the mid element with the key. If the key is
less than mid element, move to left and if it is greater than the mid then move search
space to the right.
Key (i.e., 23) is greater than current mid element (i.e., 16). The search space moves to the
right.

Figure 0:4 Binary Search Algorithm: Compare key with 16

School of computing and Informatics Computer Science Gutema S.

Key is less than the current mid-56. The search space moves to the left.

Figure 0:5 Binary Search Algorithm : Compare key with 56

Second Step: If the key matches the value of the mid element, the element is found and
stop search.

Figure 0:6Binary Search Algorithm: Key matches with mid

2.3 Sorting
One of the major applications in computer science is the sorting of information in
a table. Sorting algorithms arrange items in a set according to a predefined ordering
relation. The most common types of data are string information and numerical
information. The ordering relation for numeric data simply involves arranging items in
sequence from smallest to largest and from largest to smallest, which is called ascending
and descending order respectively.
The items in a set arranged in non-decreasing order are {7,11,13,16,16,19,23}. The items
in a set arranged in descending order is of the form {23,19,16,16,13,11,7}
Similarly for string information, {a, abacus, above, be, become, beyond}is in ascending
order and { beyond, become, be, above, abacus, a}is in descending order.

School of computing and Informatics Computer Science Gutema S.

There are numerous methods available for sorting information. But, not even one of them
is best for all applications. Performance of the methods depends on parameters like, size
of the data set, degree of relative order already present in the data etc.
2.3.1 Selection sort
The idea in selection sort is to find the smallest value and place it in an order, then find
the next smallest and place in the right order. This process is continued till the entire table
is sorted.

Consider the unsorted array,

a[1] a[2] a[8]
20 35 18 8 14 41 3 39

The resulting array should be

a[1] a[2] a[8]
3 8 14 18 20 35 39 41

One way to sort the unsorted array would be to perform the following steps:
 Find the smallest element in the unsorted array
 Place the smallest element in position of a[1]
i.e., the smallest element in the unsorted array is 3 so exchange the values of a[1] and
a[7]. The array now becomes,
a[1] a[2] a[8]
3 35 18 8 14 41 20 39

Now find the smallest from a[2] to a[8] , i.e., 8 so exchange the values of a[2] and
a[4] which results with the array shown below,
a[1] a[2] a[8]
3 8 18 35 14 41 20 39

Repeat this process until the entire array is sorted. The changes undergone by the array is
shown in fig 2.2.The number of moves with this technique is always of the order O(n).
School of computing and Informatics Computer Science Gutema S.
2.3.2 Insertion sort
Insertion sort is a straight forward method that is useful for small collection of data. The
idea here is to obtain the complete solution by inserting an element from the unordered
part into the partially ordered solution extending it by one element. Selecting an element
from the unordered list could be simple if the first element of that list is selected.

a[1] a[2] a[8]

20 35 18 8 14 41 3 39

Initially the whole array is unordered. So select the minimum and put it in place of a[1] to
act as sentinel. Now the array is of the form,

a[1] a[2] a[8]

3 35 18 8 14 41 20 39

Now we have one element in the sorted list and the remaining elements are in the
unordered set. Select the next element to be inserted. If the selected element is less than
the preceding element move the preceding element by one position and insert the smaller
element.

School of computing and Informatics Computer Science Gutema S.

In the above array the next element to be inserted is x=35, but the preceding element is 3
which is less than x. Hence, take the next element for insertion i.e., 18. 18 is less than 35,
so move 35 one position ahead and place 18 at that place. The resulting array will be,

a[1] a[2] a[8]

3 18 35 8 14 41 20 39

Now the element to be inserted is 8. 8 is less than 35 and 8 is also less than 18 so move
35 and 18 one position right and place 8 at a[2]. This process is carried till the sorted
array is obtained.

The changes undergone are shown in fig 2.3.

One of the disadvantages of the insertion sort method is the amount of movement of data.
In the worst case, the number of moves is of the order O(n2). For lengthy records it is
quite time consuming.

2.3.3 Merge sort

School of computing and Informatics Computer Science Gutema S.

 Figure 0:7 the process of merge sort
Merge sort begins by interpreting the inputs as n sorted files each of length one. These
are merged pair wise to obtain n/2 files of size two. If n is odd one file is of size one.
These n/2 files are then merged pair wise and so on until we are left with only one file.
The example in fig 2.4 illustrates the process of merge sort.
As illustrated in the example merge sort consists of several passes over the records being
sorted. In the first pass files of size one are merged. In the second pass the size of the files
being merged is two. In the ith pass the files being merged will be of size 2i-1. A total of
log2n passes are made over the data. Since, two files can be merged in linear time, each
pass of merge sort takes O(n) time. As there are log2n passes the total time complexity is
O(n log2n).
Strassen’s Matrix Multiplication
First we will discuss the general method of matrix multiplication and later we will discuss
Strassen’s matrix multiplication algorithm

Problem Statement

School of computing and Informatics Computer Science Gutema S.

Let us consider two matrices A and B. We want to calculate the resultant matrix C by
multiplying A and B.
Method
First, we will discuss naïve method and its complexity. Here, we are calculating C =
AXB. Using Naïve method, two matrices (A and B) can be multiplied if the order of
these matrices is p × q and q × r. Following is the algorithm
Algorithm: Matrix-Multiplication (X, Y, Z)
for i = 1 to p do
for j = 1 to r do
Z[i,j] := 0
for k = 1 to q do
Z[i,j] := Z[i,j] + X[i,k] × Y[k,j]
Complexity
Here, we assume that integer operations take O(1) time. There are three for loops in this
algorithm and one is nested in other. Hence, the algorithm takes O(n3) time to execute.
Strassen’s Matrix Multiplication Algorithm
In this context, using Strassen’s Matrix multiplication algorithm, the time consumption
can be improved a little bit.
Strassen in 1969 gave an overview on how we can find the multiplication of two 2*2
dimension matrices by the brute-force algorithm. But by using the divide and conquer
technique the overall complexity for the multiplication of two matrices has been reduced.
This happens by decreasing the total number of multiplications performed at the expense
of a slight increase in the number of additions.
Strassen has used some formulas for multiplying the two 2*2 dimension matrices where
the number of multiplications is seven, additions and subtractions are is eighteen, and in
brute force algorithm, there is eight number of multiplications and four addition.
When the order n of matrix reaches infinity, the utility of Strassen’s formula is shown by
its asymptotic superiority. For example, let us consider two matrices A and B of n*n
dimension, where n is a power of two. It can be observed that we can have four
submatrices of order n/2 * n/2 from A, B, and their product C where C is the resultant
matrix of A and B.

School of computing and Informatics Computer Science Gutema S.

The procedure of Strassen’s matrix multiplication
Here is the procedure :
Divide a matrix of the order of 2*2 recursively until we get the matrix of order 2*2.
To carry out the multiplication of the 2*2 matrix, use the previous set of formulas.
Subtraction is also performed within these eight multiplications and four additions.
To find the final product or final matrix combine the result of two matrixes.

There is a way to get all the required information with only 7 matrix multiplications,
instead of 8.
Recurrence for new algorithm is
T(n) = 7T(n/2) + O(n2)
You just need to remember 4 Rules :
 AHED (Learn it as ‘Ahead’)
 Diagonal
 Last CR
 First CR
Also, consider X as (Row +) and Y as (Column -) matrix

School of computing and Informatics Computer Science Gutema S.

School of computing and Informatics Computer Science Gutema S.
2.4 Recursion

Recursion may have the following definitions:

-The nested repetition of identical algorithm is recursion.

School of computing and Informatics Computer Science Gutema S.

-It is a technique of defining an object/process by itself.
-Recursion is a process by which a function calls itself repeatedly until some specified
condition has been satisfied.

2.4.1 When to use recursion

Recursion can be used for repetitive computations in which each action is stated in terms
of previous result. There are two conditions that must be satisfied by any recursive
procedure.
1. Each time a function calls itself it should get nearer to the solution.
2. There must be a decision criterion for stopping the process.

In making the decision about whether to write an algorithm in recursive or non-recursive

form, it is always advisable to consider a tree structure for the problem. If the structure is
simple then use non-recursive form. If the tree appears quite bushy, with little duplication
of tasks, then recursion is suitable.

The recursion algorithm for finding the factorial of a number is given below,

Algorithm : factorial-recursion
Input : n, the number whose factorial is to be found.
Output : f, the factorial of n
Method : if(n=0)
f=1
else
f=factorial(n-1) * n
if end
algorithm ends.

The general procedure for any recursive algorithm is as follows,

1. Save the parameters, local variables and return addresses.

School of computing and Informatics Computer Science Gutema S.

2. If the termination criterion is reached perform final computation and goto step 3
otherwise perform final computations and goto step 1
3. Restore the most recently saved parameters, local variable and return address and

goto the latest return address.

2.4.2 Iteration v/s Recursion

Demerits of recursive algorithms

1. Many programming languages do not support recursion, hence recursive

mathematical function is implemented using iterative methods.
2. Even though mathematical functions can be easily implemented using recursion it is
always at the cost of execution time and memory space. For example, the recursion
tree for generating 6 numbers in a fibonacci series generation is given in fig 2.5. A
fibonacci series is of the form 0,1,1,2,3,5,8,13,…etc, where the third number is the
sum of preceding two numbers and so on. It can be noticed from the fig 2.5 that, f(n-
2) is computed twice, f(n-3) is computed thrice, f(n-4) is computed 5 times.
3. A recursive procedure can be called from within or outside itself and to ensure its
proper functioning it has to save in some order the return addresses so that, a return to
the proper location will result when the return to a calling statement is made.
4. The recursive programs needs considerably more storage and will take more time.

School of computing and Informatics Computer Science Gutema S.

Demerits of iterative methods

1. Mathematical functions such as factorial and fibonacci series generation can be easily
implemented using recursion than iteration.
2. In iterative techniques looping of statement is very much necessary.

Recursion is a top down approach to problem solving. It divides the problem into pieces
or selects out one key step, postponing the rest.

Iteration is more of a bottom up approach. It begins with what is known and from this
constructs the solution step by step. The iterative function obviously uses time that is
O(n) where as recursive function has an exponential time complexity.

It is always true that recursion can be replaced by iteration and stacks. It is also true that
stack can be replaced by a recursive program with no stack.

2.5 Hashing

Hashing is a practical technique of maintaining a symbol table. A symbol table is a data

structure which allows to easily determine whether an arbitrary element is present or not.

Consider a sequential memory shown in fig 2.6. In hashing technique the address X of a
variable x is obtained by computing an arithmetic function (hashing function) f(x). Thus

School of computing and Informatics Computer Science Gutema S.

f(x) points to the address where x should be placed in the table. This address is known as
the hash address.

The memory used to store the variable using hashing technique is assumed to be
sequential. The memory is known as hash table. The hash table is partitioned into several
storing spaces called buckets and each bucket is divided into slots (fig 2.6).

If there are b buckets in the table, each bucket is capable of holding s variables, where
each variable occupies one slot. The function f(x) maps the possible variable onto the
integers 0 through b-1. The size of the space from where the variables are drawn is called
the identifier space. Let T be the identifier space, n be the number of variables/identifiers
in the hash table. Then, the ratio n/T is called the identifier density and a = n/sb is the
loading density or loading factor.

If f(x1)=f(x2), where x1and x2 are any two variables, then x1and x2 are called synonyms.
Synonyms are mapped onto the same bucket. If a new identifier is hashed into a already

complete bucket, collision occurs.

A hashing table with single slot is as given below. Let there be 26 buckets with single
slot. The identifier to be stored are GA, D, A, G, L, A2, A1, A3, A4, Z, ZA, E. Let f(x)
School of computing and Informatics Computer Science Gutema S.
be the function which maps on to a address equal to the position of the first character of
the identifier in the set of English alphabet. The hashing table generated is as shown in
fig 2.7.
Time taken to retrieve the identifiers is as follows,

Search Search
element (x) time (t)
GA 1
D 1
A 1
G 2
L 1
A2 2
A1 3
A3 5
A4 6
Z 1
ZA 10
E 6
∑t =39

Average retrieval time =(∑t)/n.

The average retrieval time entirely depends on the hashing function.

Exercise 2:
1. What are the serious short comings of the binary search method and sequential
search method.
2. Know more searching techniques involving hashing functions
3. Implement the algorithms for searching and calculate the complexities
4. Write an algorithm for the above method of selection sort and implement the
same.

School of computing and Informatics Computer Science Gutema S.

 5. Write the algorithm for merge sort method
6. Take 5 data set of length 10 and hand simulate for each method given above.
7. Try to know more sorting techniques and make a comparative study of them.
8. Write an iterative algorithm to find the factorial of a number
9. Write a recursive and iterative program for reversing a number
10. Write recursive and iterative program to find maximum and minimum in a list
of numbers.
11. Write an algorithm to implement the hashing technique and implement the
same
12. Hand simulate all algorithms for a 5 datasets.

School of computing and Informatics Computer Science Gutema S.

 Chapter 3

GRAPH THEORY AND RELATED DATA STRUCTURES

3.1 Introduction to Graph Theory

3.1.1 What is graph?

A graph G = (V, E) consists of a set of objects V = {v1, v2, …} called vertices, and
another set E = {e1, e2, …} whose elements are called edges. Each edge ek in E is
identified with an unordered pair (vi, vj) of vertices. The vertices vi, vj associated with
edge ek are called the end vertices of ek. The most common representation of graph is by
means of a diagram, in which the vertices are represented as points and each edge as a
line segment joining its end vertices. Often this diagram itself is referred to as a graph.

Fig 3-1.

In the Fig. 3-1 edge e1 having same vertex as both its end vertices is called a self-loop.
There may be more than one edge associated with a given pair of vertices, for example e4
and e5 in Fig. 3-1. Such edges are referred to as parallel edges.

School of computing and Informatics Computer Science Gutema S.

A graph that has neither self-loop nor parallel edges are called a simple graph, otherwise
it is called general graph. It should also be noted that, in drawing a graph, it is
immaterial whether the lines are drawn straight or curved, long or short: what is
important is the incidence between the edges and vertices.

A graph is also called a linear complex, a 1-complex, or a one-dimensional complex. A

vertex is also referred to as a node, a junction, a point, 0-cell, or an 0-simplex. Other
terms used for an edge are a branch, a line, an element, a 1-cell, an arc, and a 1-simplex.

Because of its inherent simplicity, graph theory has a very wide range of applications in
engineering, physical, social, and biological sciences, linguistics, and in numerous other
areas. A graph can be used to represent almost any physical situation involving discrete
objects and a relationship among them.

3.1.2 Finite and Infinite Graphs

Although in the definition of a graph neither the vertex set V nor the edge set E need be
finite, in most of the theory and almost all applications these sets are finite. A graph with
a finite number of vertices as well as a finite number of edges is called a finite graph;
otherwise, it is an infinite graph.

3.1.3 Incidence and Degree

When a vertex vi is an end vertex of some edge ej, vi and ej are said to be incident with
(on or to) each other. In Fig. 3-1, for example, edges e2, e6, and e7 are incident with
vertex v4. Two nonparallel edges are said to be adjacent if they are incident on a
common vertex. For example, e2 and e7 in Fig. 3-1 are adjacent. Similarly, two vertices
are said to be adjacent if they are the end vertices of the same edge. In Fig. 3-1, v4 and v5
are adjacent, but v1 and v4 are not.

School of computing and Informatics Computer Science Gutema S.

The number of edges incident on a vertex vi, with self-loops counted twice is called the
degree, d(vi), of vertex vi. In Fig. 3-1, for example, d(v1) = d(v3) = d(v4) = 3, d(v2) = 4,
and d(v5) = 1. The degree of a vertex is sometimes also referred to as its valency. Since
each edge contributes two degrees, the sum of the degrees of all vertices in G is twice the
number of edges in G.

3.1.4 Isolated vertex, Pendent vertex, and Null graph

A vertex having no incident edge is called an isolated vertex. In other words, isolated
vertices are vertices with zero degree. Vertex v4 and v7 in Fig. 3-2, for example, are
isolated vertices. A vertex of degree one is called a pendent vertex or an end vertex.
Vertex v3 in Fig. 3-2 is a pendant vertex. Two adjacent edges are said to be in series if
their common vertex is of degree two. In Fig. 3-2, the two edges incident on v1 are in
series.

Fig. 3-2 Graph containing isolated vertices, series edges and a pendant vertex.

In the definition of a graph G = (V, E), it is possible for the edge set E to be empty. Such
a graph, without any edges, is called a null graph. In other words, every vertex in a null
graph is an isolated vertex. A null graph of six vertices is shown in Fig. 3-3. Although
the edge set E may be empty, the vertex set V must not be empty; otherwise, there is no
graph. In other words, by definition, a graph must have at least one vertex.

School of computing and Informatics Computer Science Gutema S.

 Fig. 3-3 Null graph of six vertices.

3.2 Matrix Representation of Graphs

Although a pictorial representation of a graph is very convenient for a visual study, other
representations are better for computer processing. A matrix is a convenient and useful
way of representing a graph to a computer. Matrices lend themselves easily to
mechanical manipulations. Besides, many known results of matrix algebra can be readily
applied to study the structural properties of graphs from an algebraic point of view. In
many applications of graph theory, such as in electrical network analysis and operation
research, matrices also turn out to be the natural way of expressing the problem.

3.2.1 Incidence Matrix

Let G be a graph with n vertices, e edges, and no self-loops. Define an n by e matrix A

=[aij], whose n rows correspond to the n vertices and the e columns correspond to the e
edges, as follows:
The matrix element
Aij = 1, if jth edge ej is incident on ith vertex vi, and
= 0, otherwise.

School of computing and Informatics Computer Science Gutema S.

 (a)

a b c d e f g h

v1 0 0 0 1 0 1 0 0
v2 0 0 0 0 1 1 1 1
v3 0 0 0 0 0 0 0 1
v4 1 1 1 0 1 0 0 0
v5 0 0 1 1 0 0 1 0
v6 1 1 0 0 0 0 0 0

(b)
Fig. 3-4 Graph and its incidence matrix.

Such a matrix A is called the vertex-edge incidence matrix, or simply incidence matrix.
Matrix A for a graph G is sometimes also written as A(G). A graph and its incidence
matrix are shown in Fig. 3-4. The incidence matrix contains only two elements, 0 and 1.
Such a matrix is called a binary matrix or a (0, 1)-matrix.

The following observations about the incidence matrix A can readily be made:

School of computing and Informatics Computer Science Gutema S.

 1. Since every edge is incident on exactly two vertices, each column of A has
exactly two 1’s.
2. The number of 1’s in each row equals the degree of the corresponding vertex.
3. A row with all 0’s, therefore, represents an isolated vertex.
4. Parallel edges in a graph produce identical columns in its incidence matrix, for
example, columns 1 and 2 in Fig. 3-4.

3.3 Trees

The concept of a tree is probably the most important in graph theory, especially for those
interested in applications of graphs.

A tree is a connected graph without any circuits. The graph in Fig 3-5 for instance, is a
tree. It follows immediately from the definition that a tree has to be a simple graph, that
is, having neither a self-loop nor parallel edges (because they both form circuits).

Fig. 3-5. Tree

Trees appear in numerous instances. The genealogy of a family is often represented by

means of a tree. A river with its tributaries and sub-tributaries can also be represented by
a tree. The sorting of mail according to zip code and the sorting of punched cards are
done according to a tree (called decision tree or sorting tree).

3.3.1 Some properties of Trees

School of computing and Informatics Computer Science Gutema S.

 1. There is one and only one path between every pair of vertices in a tree, T.
2. A tree with n vertices has n-1 edges.
3. Any connected graph with n vertices and n-1 edges is a tree.
4. A graph is a tree if and only if it is minimally connected.

Therefore a graph with n vertices is called a tree if

1. G is connected and is circuit less, or

2. G is connected and has n-1 edges, or
3. G is circuit less and has n-1 edges, or
4. There is exactly one path between every pair of vertices in G, or
5. G is a minimally connected graph.

School of computing and Informatics Computer Science Gutema S.

 Fig. 3-6 Tree of a monotonically increasing sequences in 4,1,13,7,0,2,8,11,3

3.3.2 Pendent Vertices in a Tree

It is observed that a tree shown in the Fig. 3-5 has several pendant vertices. A pendant
vertex was defined as a vertex of degree one). The reason is that in a tree of n vertices
we have n-1 edges, and hence 2(n-1) degrees to be divided among n vertices. Since no
vertex can be of zero degree, we must have at least two vertices of degree one in a tree.
This makes sense only if n  2.

An Application: The following problem is used in teaching computer programming.

Given a sequence of integers, no two of which are the same find the largest
monotonically increasing subsequence in it. Suppose that the sequence given to us is
4,1,13,7,0,2,8,11,3; it can be represented by a tree in which the vertices (except the start
vertex) represent individual numbers in the sequence, and the path from the start vertex to
a particular vertex v describes the monotonically increasing subsequence terminating in v.
As shown in Fig. 3-6, this sequence contains four longest monotonically increasing
subsequences, that is, (4,7,8,11), (1,7,8,11), (1,2,8,11) and (0,2,8,11). Each is of length
four. Computer programmers refer to such a tree used in representing data as a data tree.

3.3.3 Rooted and Binary Tree

A tree in which one vertex (called the root) is distinguished from all the others is called a
rooted tree. For instance, in Fig. 3-6 vertex named start, is distinguished from the rest of
the vertices. Hence vertex start can be considered the root of the tree, and so the tree is
rooted. Generally, the term tree means trees without any root. However, for emphasis
they are sometimes called free trees (or non rooted trees) to differentiate them from the
rooted kind.

School of computing and Informatics Computer Science Gutema S.

 Fig. 3-6 Tree.

Binary Trees: A special class of rooted trees, called binary rooted trees, is of particular
interest, since they are extensively used in the study of computer search methods, binary
identification problems, and variable-length binary codes. A binary tree is defined as a
tree in which there is exactly one vertex of degree two, and each of the remaining vertices
of degree one or three. Since the vertex of degree two is distinct from all other vertices,
this vertex serves as a root. Thus every binary tree is a rooted tree.

3.3.4 Spanning Trees

So far we have discussed the trees when it occurs as a graph by itself. Now we shall
study the tree as a subgraph of another graph. A given graph has numerous subgraphs,
from e edges, 2e distinct combinations are possible. Obviously, some of these subgrphs
will be trees. Out of these trees we are particularly interested in certain types of trees,
called spanning trees.

A tree T is said to be a spanning tree of a connected graph G if T is a subgraph of G and

T contains all vertices of G. Since the vertices of G are barely hanging together in a
spanning tree, it is a sort of skeleton of the original graph G. This is why a spanning tree
is sometimes referred to as a skeleton or scaffolding of G. Since spanning trees are the
largest trees among all trees in G, it is also quite appropriate to call a spanning tree a
maximal tree subgraph or maximal tree of G.

School of computing and Informatics Computer Science Gutema S.

Finding a spanning tree of a connected graph G is simple. If G has no circuit, it is its own
spanning tree. If G has a circuit, delete an edge from the circuit. This will still leave the
graph connected. If there are more circuits, repeat the operation till an edge from the last
circuit is deleted, leaving a connected, circuit-free graph that contains all the vertices of
G.

3.3.5 Hamiltonian Paths and Circuits

Hamiltonian circuit in a connected graph is defined as a closed walk that traverses every
vertex of G exactly once, except of course the starting vertex, at which the walk also
terminates. A circuit in a connected graph G is said to be Hamiltonian if it includes every
vertex of G. Hence a Hamiltonian circuit in a graph of n vertices consists of exactly n
edges.

Hamiltonian path: If we remove any one edge from a Hamiltonian circuit, we are left
with a path. This path is called a Hamiltonian path. Clearly, a Hamiltonian path in a
graph G traverses every vertex of G. Since a Hamiltonian path is a subgraph of a
Hamiltonian circuit (which in turn is a subgraph of another graph), every graph that has a
Hamiltonian circuit also has a Hamiltonian path. There are, however, many graphs with
Hamiltonian paths that have no Hamiltonian circuits. The length of a Hamiltonian path
in a connected graph of n vertices is n-1.

3.3.5 Traveling-Salesman Problem

A problem closely related to the question of Hamiltonian circuits is the Traveling-

salesman problem, stated as follows: A salesman is required to visit a number of cities
during a trip. Given the distances between the cities, in what order should he travel so as
to visit every city precisely once and return home, with the minimum mileage traveled?

School of computing and Informatics Computer Science Gutema S.

Representing the cities by vertices and the roads between them by edges, we get a graph.
In this graph, with every edge ei there is associated a real number (the distance in miles,
say), w(ei). Such a graph is called a weighted graph; w(ei) being the weight of edge ei.

In our problem, if each of the cities has a road to every other city, we have a complete
weighted graph. This graph has numerous Hamiltonian circuits, and we are to pick the
one that has the smallest sum of distances (or weights).

The total number of different (not edge disjoint, of course) Hamiltonian circuits in a
complete graph of n vertices can be shown to be (n-1)! / 2. This follows from the fact
that starting from any vertex we have n-1 edges to choose from the first vertex, n-2 from
the second, n-3 from the third, and so on. These being independent, results with (n-1)!
choices. This number is, however, divided by 2, because each Hamiltonian circuit has
been counted twice.

Theoretically, the problem of the traveling salesman can always be solved by

enumerating all (n-1)!/2 Hamiltonian circuits, calculating the distance traveled in each,
and then picking the shortest one. However, for a large value of n, the labor involved is
too great even for a digital computer.

The problem is to prescribe a manageable algorithm for finding the shortest route. No
efficient algorithm for problems of arbitrary size has yet been found, although many
attempts have been made. Since this problem has applications in operations research,
some specific large-scale examples have been worked out. There are also available
several heuristic methods of solution that give a route very close to the shortest one, but
do not guarantee the shortest.

School of computing and Informatics Computer Science Gutema S.

Exercise 3

1. Draw all simple graphs of one, two, three and four vertices
2. Name 10 situations that can be represented by means of graphs. Explain what
each vertex and edge represent
3. Draw a connected graph that becomes disconnected when any edge is
removed from it
4. Draw all trees of n labeled vertices for n=1,2,3,4 and 5
5. Sketch all binary trees with six pendent edges
6. Sketch all spanning trees of given graphs in this chapter
7. Write incidence matrix for all the graphs developed
8. Find the spanning trees for all the graphs developed
9. Draw a graph which has Hamiltonian path but does not have Hamiltonian
circuit
10. List different paths from vertex1 to vertex n in each graph developed.

School of computing and Informatics Computer Science Gutema S.

 Chapter 4
DIVIDE AND CONQUER

There are a number of general and powerful computational strategies that are repeatedly
used in computer science. It is often possible to phrase any problem in terms of these
general strategies. These general strategies are Divide and Conquer, Dynamic
Programming. The techniques of Greedy Search, Backtracking and Branch and Bound
evaluation are variations of dynamic programming idea. All these strategies and
techniques are discussed in the subsequent chapters.

The most widely known and often used of these is the divide and conquer strategy.

The basic idea of divide and conquer is to divide the original problem into two or more
sub-problems which can be solved by the same technique. If it is possible to split the
problem further into smaller and smaller sub-problems, a stage is reached where the sub-
problems are small enough to be solved without further splitting. Combining the
solutions of the individuals we get the final conquering. Combining need not mean,
simply the union of individual solutions.

Divide and Conquer involves four steps

1) Divide
2) Conquer [Initial Conquer occurred due to solving]
3) Combine
4) Conquer [Final Conquer].

In precise, forward journey is divide and backward journey is Conquer. A general binary
divide and conquer algorithm is :

Procedure D&C (P,Q) //the data size is from p to q

{

School of computing and Informatics Computer Science Gutema S.

 If size(P,Q) is small Then
Solve(P,Q)
Else
M  divide(P,Q)
Combine (D&C(P,M), D&C(M+1,Q))
}

Sometimes, this type of algorithm is known as control abstract algorithms as they give an
abstract flow. This way of breaking down the problem has found wide application in
sorting, selection and searching algorithm.

4.1 Binary Search:

Algorithm:
m (p+q)/2
If (p  m  q) Then do the following Else Stop
If (A(m) = Key Then ‘successful’ stop
Else
If (A(m) < key Then
q=m-1;
Else
pm+1
End Algorithm.

Illustration :

Consider the data set with elements {12,18,22,32,46,52,59,62,68}. First let us consider
the simulation for successful cases.

Successful cases:

School of computing and Informatics Computer Science Gutema S.

 Key=12 P Q m Search
1 9 5 x
1 4 2 x
1 1 1 successful

To search 12, 3 units of time is required

Key=18 P Q m Search
1 9 5 x
1 4 2 successful

To search 18, 2 units of time is required

Key=22 P Q m Search
1 9 5 x
1 4 2 x
3 4 3 successful

To search 22, 3 units of time is required

Key=32 P Q m Search
1 9 5 x
1 4 2 x
3 4 3 x
4 4 4 successful

To search 32, 4 units of time is required

Key=46 P Q m Search
1 9 5 successful

School of computing and Informatics Computer Science Gutema S.

 To search 46, 1 unit of time is required
Key=52 P Q m Search
1 9 5 x
6 9 7 x
6 6 6 successful

To search 52, 3 units of time is required

Key=59 P Q m Search
1 9 5 x
6 9 7 successful

To search 59, 2 units of time is required

Key=62 P Q m Search
1 9 5 x
6 9 7 x
8 9 8 successful

To search 62, 3 units of time is required

Key=68 P Q m Search
1 9 5 x
6 9 7 x
8 9 8 x
9 9 9 successful

To search 68, 4 units of time is required

3+2+3+4+1+3+2+4
Successful average search time= -------------------------

School of computing and Informatics Computer Science Gutema S.

 9

unsuccessful cases

Key=25 P Q m Search
1 9 5 x
1 4 2 x
3 4 3 x
4 4 4 x

To search 25, 4 units of time is required

Key=65 P Q m Search
1 9 5 x
6 9 7 x
8 9 8 x
9 9 9 x

To search 65, 4 units of time is required

4+4
Unsuccessful search time =--------------------
2

average (sum of unsuccessful search time

search = + sum of Successful search time)/(n+(n+1))
time

School of computing and Informatics Computer Science Gutema S.

4.2 Max-Min Search:

Max-Min search problem aims at finding the smallest as well as the biggest element in a
vector A of n elements.

Following the steps of Divide and Conquer the vector can be divided into sub-problem as
shown below.

The search has now reduced to comparison of 2 numbers. The time is spent in
conquering and comparing which is the major step in the algorithm.

Algorithm: Max-Min (p, q, max, min)

{
If (p = q) Then
max = a(p)
min = a(q)
Else
School of computing and Informatics Computer Science Gutema S.
 If ( p – q-1) Then
If a(p) > a(q) Then
max = a(p)
min = a(q)
Else
max = a(q)
min = a(p)
If End
Else
m  (p+q)/2
max-min(p,m,max1,min1)
max-min(m+1,q,max2,min2)

max  large(max1,max2)
min  small(min1,min2)
If End
If End
Algorithm End.

Illustration

School of computing and Informatics Computer Science Gutema S.

Consider a data set with elements {82,36,49,91,12,14,06,76,92}. Initially the max and
min variables have null values. In the first call, the list is broken into two equal halves..
The list is again broken down into two. This process is continued till the length of the list
is either two or one. Then the maximum and minimum values are chosen from the
smallest list and these values are returned to the preceding step where the length of the
list is slightly big. This process is continued till the entire list is searched. The detail
description is shown in fig 4.1

4.3 Integer multiplication

There are various methods of obtaining the product of two numbers. The repeated
addition method is left as an assignment for the reader. The reader is expected to find the
product of some bigger numbers using the repeated addition method.

Another way of finding the product is the one we generally use i.e., the left shift method.

School of computing and Informatics Computer Science Gutema S.

4.3.1 left shift method

981*1234
3924
2943*
1962**
981***
1210554

In this method, a=981 is the multiplicand and b=1234 is the multiplier. A is multiplied by
every digit of b starting from right to left. On each multiplication the subsequent products
are shifted one place left. Finally the products obtained by multiplying a by each digit of
b is summed up to obtain the final product.

The above product can also be obtained by a right shift method, which can be illustrated
as follows,

4.3.2 right shift method

981*1234
981
1962
*2943
**3924

1210554

In the above method, a is multiplied by each digit of b from leftmost digit to rightmost
digit. On every multiplication the product is shifted one place to the right and finally all
the products obtained by multiplying ‘a’ by each digit of ‘b’ is added to obtain the final
result.

School of computing and Informatics Computer Science Gutema S.

The product of two numbers can also be obtained by dividing ‘a’ and multiplying ‘b’ by 2
repeatedly until a<=1.

4.3.3 halving and doubling method

Let a=981 and b=1234

The steps to be followed are

1. If a is odd store b
2. A=a/2 and b=b*2
3. Repeat step 2 and step 1 till a<=1

a b result
981 1234 1234
490 2468 ----------
--
245 4936 4936
122 9872 ---------
61 19744 19744
30 39488 ----------
--
15 78976 78976
7 157952 157952
3 315904 315904
1 631808 631808
Sum=1210554
The above method is called the halving and doubling method.

School of computing and Informatics Computer Science Gutema S.

4.3.4 Speed up algorithm:

In this method we split the number till it is easier to multiply. i.e., we split 0981 into 09
and 81 and 1234 into 12 and 34. 09 is then multiplied by both 12 and 34 but, the products
are shifted ‘n’ places left before adding. The number of shifts ‘n’ is decided as follows

Multiplication shifts
sequence
09*12 4 108****
09*34 2 306**
81*12 2 972**
81*34 0 2754
Sum=1210554

For 0981*1234, multiplication of 34 and 81 takes zero shifts, 34*09 takes 2 shifts, 12 and
81 takes 2 shifts and so on.

Exercise 4
1. Write the algorithm to find the product of two numbers for all the methods explained.
2. Hand simulate the algorithm for atleast 10 different numbers.
3. Implement the same for verification.
4. Write a program to find the maximum and minimum of the list of n element with and
without using recursion.

School of computing and Informatics Computer Science Gutema S.

 Chapter 5

GREEDY METHOD

Greedy method is a method of choosing a subset of the dataset as the solution set that
results in some profit. Consider a problem having n inputs, we are required to obtain the
solution which is a series of subsets that satisfy some constraints or conditions. Any
subset, which satisfies these constraints, is called a feasible solution. It is required to
obtain the feasible solution that maximizes or minimizes the objective function. This
feasible solution finally obtained is called optimal solution.

If one can devise an algorithm that works in stages, considering one input at a time and at
each stage, a decision is taken on whether the data chosen results with an optimal solution
or not. If the inclusion of a particular data results with an optimal solution, then the data
is added into the partial solution set. On the other hand, if the inclusion of that data
results with infeasible solution then the data is eliminated from the solution set.

The general algorithm for the greedy method is

1) Choose an element e belonging to dataset D.
2) Check whether e can be included into the solution set S if Yes solution set is s 
s U e.
3) Continue until s is filled up or D is exhausted whichever is earlier.

5.1 Cassette Filling

Consider n programs that are to be stored on a tape of length L. Each program I is of

length li where i lies between 1 and n. All programs can be stored on the tape iff the sum
of the lengths of the programs is at most L. It is assumed that, whenever a program is to
be retrieved the tape is initially positioned at the start end.

Let tj be the time required retrieving program ij where programs are stored in the order
I = i1, i2, i3, …,in.

School of computing and Informatics Computer Science Gutema S.

The time taken to access a program on the tape is called the mean retrieval time (MRT)
i.e., tj =lik k=1,2,…,j

Now the problem is to store the programs on the tape so that MRT is minimized. From
the above discussion one can observe that the MRT can be minimized if the programs are
stored in an increasing order i.e., l1  l2  l3, … ln.

Hence the ordering defined minimizes the retrieval time. The solution set obtained need
not be a subset of data but may be the data set itself in a different sequence.

Illustration

Assume that 3 sorted files are given. Let the length of files A, B and C be 7, 3 and 5 units
respectively. All these three files are to be stored on to a tape S in some sequence that
reduces the average retrieval time. The table shows the retrieval time for all possible
orders.

Order of Retrieval time MRT

recording
ABC 7+(7+3)+(7+3+5)=32 32/3
ACB 7+(7+5)+(7+5+3)=34 34/3
BAC 3+(3+7)+(3+7+5)=28 28/3
BCA 3+(3+5)+(3+5+7)=26 26/3
CAB 5+(5+7)+(5+7+3)=32 32/3
CBA 5+(5+3)+(5+3+7)=28 28/3

5.2 General Knapsack problem:

School of computing and Informatics Computer Science Gutema S.

Greedy method is best suited to solve more complex problems such as a knapsack
problem. In a knapsack problem there is a knapsack or a container of capacity M n items
where, each item i is of weight wi and is associated with a profit pi. The problem of
knapsack is to fill the available items into the knapsack so that the knapsack gets filled up
and yields a maximum profit. If a fraction xi of object i is placed into the knapsack, then a
profit pixi is earned. The constrain is that all chosen objects should sum up to M

Illustration

Consider a knapsack problem of finding the optimal solution where, M=15,

(p1,p2,p3…p7) = (10, 5, 15, 7, 6, 18, 3) and (w1, w2, …., w7) = (2, 3, 5, 7, 1, 4, 1).

In order to find the solution, one can follow three different srategies.

Strategy 1 : non-increasing profit values

Let (a,b,c,d,e,f,g) represent the items with profit (10,5,15,7,6,18,3) then the sequence of
objects with non-increasing profit is (f,c,a,d,e,b,g).

Item chosen Quantity of item Remaining PiXi

for inclusion included space in M
F 1 full unit 15-4=11 18*1=18
C 1 full unit 11-5=6 15*1=15
A 1 full unit 6-2=4 10*1=10
D 4/7 unit 4-4=0 4/7*7=04
Profit= 47 units
The solution set is (1,0,1,4/7,0,1,0).

Strategy 2: non-decreasing weights

The sequence of objects with non-decreasing weights is (e,g,a,b,f,c,d).

School of computing and Informatics Computer Science Gutema S.

 Item chosen Quantity of item Remaining PiX I
for inclusion included space in M
E 1 full unit 15-1=14 6*1=6
G 1 full unit 14-1=13 3*1=3
A 1 full unit 13-2=11 10*1=10
B 1 full unit 11-3=8 5*1=05
F 1 full unit 8-4=4 18*1=18
C 4/5 unit 4-4=0 4/5*15=12
Profit= 54 units
The solution set is (1,1,4/5,0,1,1,1).

Strategy 2: maximum profit per unit of capacity used

(This means that the objects are considered in decreasing order of the ratio P i/wI)

a: P1/w1 =10/2 = 5 b: P2/w2 =5/3=1.66 c: P3/w3 =15/5 = 3

d: P4/w4 =7/7=1 e: P5/w5 =6/1=6 f: P6/w6 =18/4 = 4.5

g: P7/w7 =3/1=3

Hence, the sequence is (e,a,f,c,g,b,d)

Item chosen Quantity of item Remaining PiX I

for inclusion included space in M
E 1 full unit 15-1=14 6*1=6
A 1 full unit 14-2=12 10*1=10
F 1 full unit 12-4=8 18*1=18
C 1 full unit 8-5=3 15*1=15
G 1 full unit 3-1=2 3*1=3
B 2/3 unit 2-2=0 2/3*5=3.33
Profit= 55.33 units

School of computing and Informatics Computer Science Gutema S.

The solution set is (1,2/3,1,0,1,1,1).
In the above problem it can be observed that, if the sum of all the weights is  M then all
xi = 1, is an optimal solution. If we assume that the sum of all weights exceeds M, all x i’s
cannot be one. Sometimes it becomes necessary to take a fraction of some items to
completely fill the knapsack. This type of knapsack problems is a general knapsack
problem.

5.3 Job Scheduling:

In a job-scheduling problem, we are given a list of n jobs. Every job i is associated with
an integer deadline di  0 and a profit pi  0 for any job i, profit is earned if and only if
the job is completed within its deadline. A feasible solution with maximum sum of
profits is to be obtained now.

To find the optimal solution and feasibility of jobs we are required to find a subset J such
that each job of this subset can be completed by its deadline. The value of a feasible
solution J is the sum of profits of all the jobs in J.

Steps in finding the subset J are as follows:

a)  pi i  J is the objective function chosen for optimization measure.
b) Using this measure, the next job to be included should be the one which increases
 pi i  J.
c) Begin with J =  and  pi = 0 i J
d) Add a job to J which has the largest profit
e) Add another job to this J keeping in mind the following condition:
i) Search for job which has the next maximum profit.
ii) See if this job is union with J is feasible or not.
iii) If yes go to step (e) and continue else go to (iv)
iv) Search for the job with next maximum profit and go to step (b)
f) Terminate when addition of no more jobs is feasible.

School of computing and Informatics Computer Science Gutema S.

Illustration:

Consider 5 jobs with profits (p1,p2,p3,p4,p5) = (20,15,10,5,1) and maximum delay

allowed (d1,d2,d3,d4,d5) = (2,2,1,3,3).

Here maximum number of jobs that can be completed is = Min(n,maxdelay(di))

= Min(5,3)
= 3.
Hence there is a possibility of doing 3 jobs.

There are 3 units of time

Time Slot
[0-1] [1-2] [2-3] Profit
Job
1 - yes - 20
2 yes - - 15
3 cannot accommodate --
4 - - yes 5

40

In the first unit of time job 2 is done and a profit of 15 is gained, in the second unit job 1
is done and a profit 20 is obtained finally in the 3rd unit since the third job is not available
4th job is done and 5 is obtained as the profit in the above job 3 and 5 could not be
accommodated due to their deadlines.

Exercise 5
1) Write the algorithm for solving cassette-filling problem on your own.
2) When one medium is not enough to store all files how do you solve it.
3) Write the algorithm to implement knapsack problem

School of computing and Informatics Computer Science Gutema S.

 4) What is 0/1 knapsack, write algorithm and know the difference between general
knapsack and 0/1 knapsack.
5) Write the algorithm for job scheduling method.
6) Solve for 4 job with profits (100,10,15,27) and delays (2,1,2,1)

School of computing and Informatics Computer Science Gutema S.

 Chapter 6

BRANCH AND BOUND and BACKTRACKING

6.1 Backtracking

Problems, which deal with searching a set of solutions, or which ask for an optimal
solution satisfying some constraints can be solved using the backtracking formulation.
The backtracking algorithm yields the proper solution in fewer trials.

The basic idea of backtracking is to build up a vector one component at a time and to test
whether the vector being formed has any chance of success. The major advantage of this
algorithm is that if it is realized that the partial vector generated does not lead to an
optimal solution then that vector may be ignored.

Backtracking algorithm determine the solution by systematically searching the solution

space for the given problem. This search is accomplished by using a free organization.
Backtracking is a depth first search with some bounding function. All solutions using
backtracking are required to satisfy a complex set of constraints. The constraints may be
explicit or implicit.

Explicit constraints are rules, which restrict each vector element to be chosen from the
given set. Implicit constraints are rules, which determine which of the tuples in the
solution space, actually satisfy the criterion function.

6.1.1 Cassette filling problem:

School of computing and Informatics Computer Science Gutema S.

There are n programs that are to be stored on a tape of length L. Every program ‘i’ is of
length li. All programs can be stored on the tape if and only if the sum of the lengths of
the programs is at most L. In this problem, it is assumed that whenever a program is to be
retrieved, the tape is positioned at the start end. Hence, the time tj needed to retrieve
program ij from a tape having the programs in the order i1,i2, …,in is called mean retrieval
time(MRT) and is given by
tj =lik k=1,2,…,j

In the optimal storage on tape problem, we are required to find a permutation for the n
programs so that when they are stored on the tape, the MRT is minimized.

Let n=3 and (l1,l2,l3)=(5,10,3),there are n!=6 possible orderings. These orderings and their
respective MRT is given in the fig 6.1. Hence, the best order of recording is 3,1,2.

6.1.2 Subset problem:

There are n positive numbers given in a set. The desire is to find all possible subsets of
this set, the contents of which add onto a predefined value M.

School of computing and Informatics Computer Science Gutema S.

Let there be n elements in the main set. W=w[1..n] represent the elements of the set. i.e.,
w = (w1,w2,w3,…,wn) vector x = x[1..n] assumes either 0 or 1 value. If element w(i) is
included in the subset then x(i) =1.

Consider n=6 m=30 and w[1..6]={5,10,12,13,15,18}. The partial backtracking tree is

shown in fig 6.2. The label to the left of a node represents the item number chosen for
insertion and the label to the right represents the space occupied in M. S represents a
solution to the given problem and B represents a bounding criteria if no solution can be
reached. For the above problem the solution could be (1,1,0,0,1,0), (1,0,1,1,0,0) and
(0,0,1,0,0,1). Completion of the tree structure is left as an assignment for the reader.

6.3.3 8 queen problem:

The 8 queen problem can be stated as follows. Consider a chessboard of order 8X8. The
problem is to place 8 queens on this board such that no two queens are attack can attack
each other.

School of computing and Informatics Computer Science Gutema S.

Illustration.
Consider the problem of 4 queens, backtracking solution for this is as shown in the fig
6.3. The figure shows a partial backtracking tree. Completion of the tree is left as an
assignment for the reader.

6.2 Branch and Bound:

The term branch and bound refer to all state space search methods in which all possible
branches are derived before any other node can become the E-node. In other words the
exploration of a new node cannot begin until the current node is completely explored.

6.2.1 Tape filling:

The branch and bound tree for the records of length (5,10,3) is as shown in fig 6.4

School of computing and Informatics Computer Science Gutema S.

 Chapter 7:

GRAPH THEORETIC ALGORITHMS

7.1 Single-source shortest path:

Graphs can be used to represent the highway structure of a state or country with vertices
representing cities and edges representing sections of highway. The edges can then be
assigned weights which may be either the distance between the two cities connected by
the edge or the average time to drive along that section of highway. A motorist wishing
to drive from city A to B would be interested in answers to the following questions:

1) Is there a path from A to B?

2) If there is more than one path from A to B? Which is the shortest path?

The problems defined by these questions are special case of the path problem we
study in this section. The length of a path is now defined to be the sum of the
weights of the edges on that path. The starting vertex of the path is referred to as
the source and the last vertex the destination. The graphs are digraphs
representing streets. Consider a digraph G=(V,E), with the distance to be traveled
as weights on the edges. The problem is to determine the shortest path from v0 to
all the remaining vertices of G. It is assumed that all the weights associated with

the edges are positive. The shortest path between v0 and some other node v is an
ordering among a subset of the edges. Hence this problem fits the ordering
paradigm.

School of computing and Informatics Computer Science Gutema S.

 Example:

Consider the digraph of fig 7-1. Let the numbers on the edges be the costs of
travelling along that route. If a person is interested travel from v1 to v2, then he
encounters many paths. Some of them are

1) v1 v2 = 50 units
2) v1v3v4 v2 = 10+15+20=45 units
3) v1v5v4v2 = 45+30+20= 95 units
4) v1v3v4v5v4v2 = 10+15+35+30+20=110 units

The cheapest path among these is the path along v1v3v4v2. The cost of
the path is 10+15+20 = 45 units. Even though there are three edges on this path,
it is cheaper than travelling along the path connecting v1 and v2 directly i.e., the
path v1v2 that costs 50 units. One can also notice that, it is not possible to
travel to v6 from any other node.

To formulate a greedy based algorithm to generate the cheapest paths, we must

conceive a multistage solution to the problem and also of an optimization
measure. One possibility is to build the shortest paths one by one. As an
optimization measure we can use the sum of the lengths of all paths so far
generated. For this measure to be minimized, each individual path must be of
minimum length. If we have already constructed i shortest paths, then using this
optimization measure, the next path to be constructed should be the next shortest
minimum length path. The greedy way to generate these paths in non-decreasing
order of path length. First, a shortest path to the nearest vertex is generated. Then
a shortest path to the second nearest vertex is generated, and so on.

School of computing and Informatics Computer Science Gutema S.

 A much simpler method would be to solve it using matrix representation. The
steps that should be followed is as follows,

Step 1: find the adjacency matrix for the given graph. The adjacency matrix for
fig 7.1 is given below

V1 V2 V3 V4 V5 V6

V1 - 50 10 Inf 45 Inf
V2 Inf - 15 Inf 10 Inf
V3 20 Inf - 15 inf Inf
V4 Inf 20 Inf - 35 Inf
V5 Inf Inf Inf 30 - Inf
V6 Inf Inf Inf 3 Inf -

Step 2: consider v1 to be the source and choose the minimum entry in the row v1.
In the above table the minimum in row v1 is 10.

Step 3: find out the column in which the minimum is present, for the above
example it is column v3. Hence, this is the node that has to be next visited.
Step 4: compute a matrix by eliminating v1 and v3 columns. Initially retain only row v1.
The second row is computed by adding 10 to all values of row v3.
The resulting matrix is

V2 V4 V5 V6
V1Vw 50 Inf 45 Inf
V1V3Vw 10+inf 10+15 10+inf 10+inf
Minimum 50 25 45 inf

School of computing and Informatics Computer Science Gutema S.

 Step 5: find the minimum in each column. Now select the minimum from the resulting
row. In the above example the minimum is 25. Repeat step 3 followed by step 4 till all
vertices are covered or single column is left.

The solution for the fig 7.1 can be continued as follows

V2 V5 V6
V1Vw 50 45 Inf
V1V3V4Vw 25+20 25+35 25+inf
Minimum 45 45 inf

V5 V6
V1Vw 45 Inf
V1V3V4V2V 45+10 45+inf
w
Minimum 45 inf

V6
V1Vw Inf
V1V3V4V2V5Vw 45+inf
Minimum inf

Finally the cheapest path from v1 to all other vertices is given by

V1V3V4V2V5.

7.2 Minimum-Cost spanning trees

Let G=(V,E) be an undirected connected graph. A sub-graph t = (V,E1) of G is a

spanning tree of G if and only if t is a tree.

School of computing and Informatics Computer Science Gutema S.

Above figure shows the complete graph on four nodes together with three of its spanning
tree.

Spanning trees have many applications. For example, they can be used to obtain an
independent set of circuit equations for an electric network. First, a spanning tree for the
electric network is obtained. Let B be the set of network edges not in the spanning tree.
Adding an edge from B to the spanning tree creates a cycle. Kirchoff’s second law is
used on each cycle to obtain a circuit equation.

Another application of spanning trees arises from the property that a spanning tree is a
minimal sub-graph G’ of G such that V(G’) = V(G) and G’ is connected. A minimal sub-
graph with n vertices must have at least n-1 edges and all connected graphs with n-1
edges are trees. If the nodes of G represent cities and the edges represent possible
communication links connecting two cities, then the minimum number of links needed to
connect the n cities is n-1. the spanning trees of G represent all feasible choice.

In practical situations, the edges have weights assigned to them. Thse weights may
represent the cost of construction, the length of the link, and so on. Given such a
weighted graph, one would then wish to select cities to have minimum total cost or
minimum total length. In either case the links selected have to form a tree. If this is not
so, then the selection of links contains a cycle. Removal of any one of the links on this
cycle results in a link selection of less const connecting all cities. We are therefore
interested in finding a spanning tree of G. with minimum cost since the identification of

School of computing and Informatics Computer Science Gutema S.

a minimum-cost spanning tree involves the selection of a subset of the edges, this
problem fits the subset paradigm.

7.2.1 Prim’s Algorithm

A greedy method to obtain a minimum-cost spanning tree builds this tree edge by edge.
The next edge to include is chosen according to some optimization criterion. The simplest
such criterion is to choose an edge that results in a minimum increase in the sum of the
costs of the edges so far included. There are two possible ways to interpret this criterion.
In the first, the set of edges so far selected form a tree. Thus, if A is the set of edges
selected so far, then A forms a tree. The next edge(u,v) to be included in A is a
minimum-cost edge not in A with the property that A U {(u,v)} is also a tree. The
corresponding algorithm is known as prim’s algorithm.

For Prim’s algorithm draw n isolated vertices and label them v1, v2, v3,…vn. Tabulate
the given weights of the edges of g in an n by n table. Set the non existent edges as very
large. Start from vertex v1 and connect it to its nearest neighbor (i.e., to the vertex,
which has the smallest entry in row1 of table) say Vk. Now consider v1 and vk as one
subgraph and connect this subgraph to its closest neighbor. Let this new vertex be vi.
Next regard the tree with v1 vk and vi as one subgraph and continue the process until all
n vertices have been connected by n-1 edges.

Consider the graph shown in fig 7.3. There are 6 vertices and 12 edges. The weights are
tabulated in table given below.

School of computing and Informatics Computer Science Gutema S.

 V1 V2 V3 V4 V5 V6
V1 - 10 16 11 10 17
V2 10 - 9.5 Inf Inf 19.5
V3 16 9.5 - 7 Inf 12
V4 11 Inf 7 - 8 7
V5 10 Inf Inf 8 - 9
V6 17 19.5 12 7 9 -

Start with v1 and pick the smallest entry in row1, which is either (v1,v2) or (v1,v5). Let
us pick (v1, v5). The closest neighbor of the subgraph (v1,v5) is v4 as it is the smallest
in the rows v1 and v5. The three remaining edges selected following the above
procedure turn out to be (v4,v6) (v4,v3) and (v3, v2) in that sequence. The resulting

shortest spanning tree is shown in fig 7.4. The weight of this tree is 41.5.

7.2.3 Kruskal’s Algorithm:

There is a second possible interpretation of the optimization criteria mentioned earlier in

which the edges of the graph are considered in non-decreasing order of cost. This
interpretation is that the set t of edges so far selected for the spanning tree be such that it
is possible to complete t into a tree. Thus t may not be a tree at all stages in the
algorithm. In fact, it will generally only be a forest since the set of edges t can be
completed into a tree if and only if there are no cycles in t. this method is due to
kruskal.

School of computing and Informatics Computer Science Gutema S.

The Kruskal algorithm can be illustrated as folows, list out all edges of graph G in order of
non-decreasing weight. Next select a smallest edge that makes no circuit with previously
selected edges. Continue this process until (n-1) edges have been selected and these edges
will constitute the desired shortest spanning tree.

For fig 7.3 kruskal solution is as follows,

V1 to v2 =10
V1 to v3 = 16
V1 to v4 = 11
V1 to v5 = 10
V1 to v6 = 17
V2 to v3 = 9.5
V2 to v6 = 19.5
V3 to v4 = 7
V3 to v6 =12
V4 to v5 = 8
V4 to v6 = 7
V5 to v6 = 9

The above path in ascending order is

V3 to v4 = 7
V4 to v6 = 7
V4 to v5 = 8
V5 to v6 = 9
V2 to v3 = 9.5
V1 to v5 = 10
V1 to v2 =10
V1 to v4 = 11
V3 to v6 =12
V1 to v3 = 16

School of computing and Informatics Computer Science Gutema S.

V1 to v6 = 17
V2 to v6 = 19.5

Select the minimum, i.e., v3 to v4 connect them, now select v4 to v6 and then v4 to v5,
now if we select v5 to v6 then it forms a circuit so drop it and go for the next. Connect v2
and v3 and finally connect v1 and v5. Thus, we have a minimum spanning tree, which is
similar to the figure 7.4.

7.3 Techniques for graphs:

A fundamental problem concerning graphs is the reachability problem. In its simplest

form it requires us to determine whether there exists a path in the given graph G=(V,E)
such that this path starts at vertex v and ends at vertex u. A more general form is to
determine for a given starting

Vertex v belonging to V all vertices u such that there is a path from v to u. This latter
problem can be solved by starting at vertex v and systematically searching the graph G
for vertices that can be reached from v. The 2 search methods for this are :
1) Breadth first search.
2) Depth first search.

7.3.1 Breadth first search:

In Breadth first search we start at vertex v and mark it as having been reached. The vertex
v at this time is said to be unexplored. A vertex is said to have been explored by an
algorithm when the algorithm has visited all vertices adjacent from it. All unvisited
vertices adjacent from v are visited next. There are new unexplored vertices. Vertex v has
now been explored. The newly visited vertices have not been explored and are put onto
the end of the list of unexplored vertices. The first vertex on this list is the next to be
explored. Exploration continues until no unexplored vertex is left. The list of unexplored
vertices acts as a queue and can be represented using any of the standard queue
representations.

School of computing and Informatics Computer Science Gutema S.

7.3.2 Depth first search:

A depth first search of a graph differs from a breadth first search in that the
exploration of a vertex v is suspended as soon as a new vertex is reached. At this time the
exploration of the new vertex u begins. When this new vertex has been explored, the
exploration of u continues. The search terminates when all reached vertices have been
fully explored. This search process is best-described recursively.

Algorithm DFS(v)
{
visited[v]=1
for each vertex w adjacent from v do
{
If (visited[w]=0)then
DFS(w);
}
}

7.4 Heaps and Heap sort:

A heap is a complete binary tree with the property that the value at each node is atleast as
large as the value at its children.

The definition of a max heap implies that one of the largest elements is at the root of the
heap. If the elements are distinct then the root contains the largest item. A max heap can
be implemented using an array an[ ].

To insert an element into the heap, one adds it “at the bottom” of the heap and then
compares it with its parent, grandparent, great grandparent and so on, until it is less than
or equal to one of these values. Algorithm insert describes this process in detail.

School of computing and Informatics Computer Science Gutema S.

 Algorithm Insert(a,n)
{
// Insert a[n] into the heap which is stored in a[1:n-1]
I=n;
item=a[n];
while( (I>n) and (a[ I!/2 ] < item)) do
{
a[I] = a[I/2];
I=I/2;
}
a[I]=item;
return (true);
}

School of computing and Informatics Computer Science Gutema S.

The figure shows one example of how insert would insert a new value into an existing
heap of five elements. It is clear from the algorithm and the figure that the time for insert
can vary. In the best case the new elements are correctly positioned initially and no new
values need to be rearranged. In the worst case the number of executions of the while
loop is proportional to the number of levels in the heap. Thus if there are n elements in
the heap, inserting new elements takes O(log n) time in the worst case.

To delete the maximum key from the max heap, we use an algorithm called Adjust.
Adjust takes as input the array a[ ] and integer I and n. It regards a[1..n] as a complete
binary tree. If the subtrees rooted at 2I and 2I+1 are max heaps, then adjust will rearrange
elements of a[ ] such that the tree rooted at I is also a max heap. The maximum elements
from the max heap a[1..n] can be deleted by deleting the root of the corresponding

School of computing and Informatics Computer Science Gutema S.

complete binary tree. The last element of the array, i.e. a[n], is copied to the root, and
finally we call Adjust(a,1,n-1).

Algorithm Adjust(a,I,n)
{
j=2I;
item=a[I];
while (j<=n) do
{
if ((j<=n) and (a[j]< a[j+1])) then
j=j+1;

//compare left and right child and let j be the right //child
if ( item >= a[I]) then break;
// a position for item is found
a[i/2]=a[j];
j=2I;
}
a[j/2]=item;
}

Algorithm Delmac(a,n,x)

// Delete the maximum from the heap a[1..n] and store it in x

{
if (n=0) then
{
write(‘heap is empty”);
return (false);
}
x=a[1];
a[1]=a[n];

School of computing and Informatics Computer Science Gutema S.

 Adjust(a,1,n-1);
Return(true);
}

Note that the worst case run time of adjust is also proportional to the height of the
tree. Therefore if there are n elements in the heap, deleting the maximum can be done in
O(log n) time.
To sort n elements, it suffices to make n insertions followed by n deletions from a
heap since insertion and deletion take O(log n) time each in the worst case this sorting
algorithm has a complexity of
O(n log n).

Algorithm sort(a,n)
{
for i=1 to n do
Insert(a,i);
for i= n to 1 step –1 do
{
Delmax(a,i,x);
a[i]=x;
}
}

References:

1. Fundamentals of computer algorithms – E. Horowitz, S.Sahni, S.Rajasekaran

2. How to solve it by computer- R.G. Dromey
3. Graph Theory with applications to engineering and computer science- Narsingh Deo
4. Fundamentals of computer algorithms – E. Horowitz, S.Sahni
5. Fundamentals of datastructures- Tremblay and Sorenson

School of computing and Informatics Computer Science Gutema S.

6. Fundamentals of datastructures in PASCAL -E. Horowitz, S.Sahni

CYCLE

1. Write a program that inputs three numbers and outputs them in ascending order.
2. Write a program to test whether the three numbers represent the sides of a right angle
triangle.
3. Write a program to test whether a given point p(x,y) lies on x-axis or y-axis or in
I/II/III/IV quadrant.
4. Write a program to compute the area of a circle
5. Write a program to compute the circumference of a circle
6. Write a program to find the roots of a quadratic equation.
7. Write a program to list all prime numbers between two limits n1 and n2
8. Write a program to find whether a given number is prime or not.
9. Write programs to implement the sorting techniques.
10. Write programs to implement the searching techniques.
11. Write a program to find the factorial of a number
12. Write a program to exchange the values of two variables with and without using a
temporary variable
13. Write a program to find the number of students who have scored above 60 percent
14. Write a program to find the sum of n numbers
15. Write a program to find the average of n numbers
16. Write a program to find the factorial of a number
17. Write a recursive function to find the factorial of a number.
18. Write a program to implement the binary search
19. Write a program to implement the sequential search
20. Write a program for the method of selection sort
21. Write a program for the method of merge sort
22. Write a recursive and iterative program for reversing a number
23. Write recursive and iterative program to find maximum and minimum in a list of
numbers.

School of computing and Informatics Computer Science Gutema S.

24. Write a program to generate the fibonacci series.
25. Write the algorithm to implement knapsack problem
26. Write a program to find mean median and standard deviation
27. Write a program to implement heap sort
28. Write a program to solve 4 queen problem
29. Write a program to implement kruskals method
30. Write a program to implement Prim’s algorithm

MODEL QUESTION PAPER

I Answer the following
25 marks
1) One of the characteristics of algorithm is
a) Definiteness b) Efficiency c) Both a & b d) Only a
2) ----------- is the process of executing a correct program on data sets and measuring
the time and space it takes to compute the results.
a) Profiling b) Compiling c) Testing d) none of the above
3) An algorithm produces ------------------ outputs
a) One b) No c) two d) More than Zero

4) An algorithm is composed of -------- set of steps

a) Null b) infinite c) Finite d) None of these
5) One of the main blocks of any iterative algorithm is
a) initialization b) Decision c) updation d) computation e) all the four
6) In sequential search, search always begins at the
a) beginning b) end of list c) middle of the list d) none of these

7) Binary search can be employed on an unsorted list (True/False)

8) In Binary search, search always begins at
a) beginning of the list b) end of the list c) middle of the list d) none of these
9) --------- is not a sorting technique
a) Binary Sort b) Bubble sort c)Quick sort d) Heap sort
10) The number of moves in selection sort is of order -----------------

School of computing and Informatics Computer Science Gutema S.

 a) O(n2)
b) O(nlogn)
c) O(n)
d) None of these
11) {3,8,14,18,20,35,39,41} is in
a) ascending order
b) decending order
c) unsorted
d) random order
12) The time complexity of merge sort is ----------
a) O(nlogn)
b) O(n2)
c) O(n/2)
d) None of these
13) -------- is a technique of defining a process by itself
a) Procedure
b) Function
c) Program
d) None of these
14) Factorial of 4 is --------
a) 24
b) 12
c) 4
d) 6
15) A graph that has neither self-loop nor parallel edges are called --------------
a) general graph
b) cyclic graph
c) directed graph
d) simple graph
16) A vertex having no incident edge is called ---------
a) pendent vertex
b) vertex

School of computing and Informatics Computer Science Gutema S.

 c) isolated vertex
d) none of these
17) Two adjacent edges are said to be in series if their common vertex is of degree ---
a) 1
b) 2
c) 3
d) 4
18) A graph without any edges and vertices is called a
a) null graph
b) simple graph
c) complex graph
d) general graph
19) ---------- is a connected graph without any circuit
a) Null graph
b) Tree
c) Simple graph
d) None of these
20) In an 8-queen problem the size of chessboard will be
a) 8 X 8
b) 4 X 4
c) 8 X 4
d) 8 X 9
21) Maximum number of jobs that can be completed in scheduling N jobs with
deadline di is
a) N jobs
b) M jobs
c) Min(N,Max(di))
d) None of the above
22) What is a Heap?
23) What is a rooted tree?
24) A tree with n vertices contains ------- edges
a) n

School of computing and Informatics Computer Science Gutema S.

 b) 2n
c) n-1
d) 0
25) What is a computational procedure?

Answer any ten

50 marks

1) Explain the different properties of an algorithm. Bring out the difference between
definiteness and effectiveness of an algorithm.
2) Briefly explain the traveling salesman problem.
3) Explain and illustrate divide and conquer algorithm to search an element.
4) Explain and illustrate divide and conquer algorithm to sort a set of elements.
5) Explain a general algorithm to find the maximum and minimum of n elements in a
list.
6) Obtain an optimal merge pattern for sorted files with lengths (2,3,5,7,9,13) using
greedy method.
7) Explain the principle of greedy method. Find an optimal sequencing of jobs, given
N=7, (p1,…,p7) = (3,5,20,18,1,6,30) (d1,…,d7) = (1,3,4,3,2,1,2).
8) Describe prim’s algorithm to determine a minimum cost spanning tree.
9) Explain recursive and non-recursive algorithms.
10) Write a module, which multiplies two single digit integers using repeated addition
algorithm. Hand simulate the algorithm to compute 52*49.
11) Demonstrate a procedure with an example to create Hash table.
12) Demonstrate the stage by stage implementation of Backtracking method to solve a
4queen problem.
13) Demonstrate the stage by state implementation of Branch and Bound method to
solve 4 queen problem.
14) Discuss Briefly the 8-queen’s problem

School of computing and Informatics Computer Science Gutema S.

 15) Explain briefly the Knapsack problem. Find an optimal solution for the knapsack
instance N=7,m=15, (p1,…,p7) = (10,5,15,7,6,18,3) and (w1…,w7) =
(2,3,5,7,1,4,1).

TERM END ASSIGNMENTS

1) Illustrate the applications of the following design strategies to objtain shortest

routes and the longest routes from the vertex V to all other vertices in the given
network. Show all hand computations step by step clarly.
Write down the algorithm with necessary details and justifications comment on
the time performance of the algorithm.
i) Greedy method and Backtracking (or)
ii) Greedy method and Branch and Bound (or)
iii) Backtracking and Branch and Bound.

2) Illustrate any two sorting techniques and 2 searching techniques. Show all hand
computations step by step clearly. Write down the algorithm with necessary details.
Comment on the performance of the algorithm.

School of computing and Informatics Computer Science Gutema S.