ADA

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 acomputer 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 thecomputer.
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.

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.

Rajat jain
ADA

1.2 Characteristics of an algorithm

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.
Thus, every algorithm should have the following five characteristic feature

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.
Rajat jain
ADA

Example 1:
Problem : finding the largest value among n>=1 numbers.
Input : the value of n and n numbers
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.

1. 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.

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

o For variable = value1 to value2 do

Block
For end
Rajat jain
ADA

Here the block is executed for all the values of the variable from value 1
to value 2.

o 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.

o 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.

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

Rajat jain
ADA

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

Rajat jain
ADA

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

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 (n th)
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)

Rajat jain
ADA

{
write("search successful")
write(k is at location i)
exit();
}
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. A search for aparticular 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.
The algorithm for binary search is as follows,
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
else
low=mid
if end
}
while end
if(k=A[low])
{
write("search successful")
write(k is at location low)
exit();
}

Rajat jain
ADA

else
write (search unsuccessful);
if end;
algorithm ends.

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

Rajat jain
ADA

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

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.
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

Rajat jain
ADA

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

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 i th 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).

Rajat jain
ADA

2.4 Recursion
Recursion may have the following definitions:
-The nested repetition of identical algorithm is recursion.
-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 thestructure 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.

2. If the termination criterion is reached perform final computation and
goto step 3 otherwise perform final computations and goto step 1

Rajat jain
ADA

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.

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.

Rajat jain
ADA

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 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.

Rajat jain
ADA

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

Rajat jain
ADA

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.
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.

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.

Rajat jain
ADA

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.
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 incidentwith 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.
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) =

Rajat jain
ADA

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 seriesif 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.

 
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

Rajat jain
ADA

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.

(a)
abcdefgh

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:

Rajat jain
ADA

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 berepresented 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

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

Rajat jain
ADA

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.

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 ofdegree 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 inv.
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
Rajat jain
ADA

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.

 
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.
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.

Rajat jain
ADA

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 mileagetraveled?
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.
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

Rajat jain
ADA

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.

4.1 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

Rajat jain
ADA

{
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 applicationin 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:
Key=12 P Q m Search
195x
142x
1 1 1 successful
To search 12, 3 units of time is required
 
Key=18 P Q m Search
195x
1 4 2 successful
To search 18, 2 units of time is required
Key=22 P Q m Search
195x
142x
3 4 3 successful
To search 22, 3 units of time is required
Key=32 P Q m Search
195x
142x
343x
4 4 4 successful
To search 32, 4 units of time is required
Key=46 P Q m Search

Rajat jain
ADA

1 9 5 successful
To search 46, 1 unit of time is required
Key=52 P Q m Search
195x
697x
6 6 6 successful
To search 52, 3 units of time is required
Key=59 P Q m Search
195x
6 9 7 successful
To search 59, 2 units of time is required
Key=62 P Q m Search
195x
697x
8 9 8 successful
To search 62, 3 units of time is required
Key=68 P Q m Search
195x
697x
898x
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= -------------------------
9
unsuccessful cases
Key=25 P Q m Search
195x
142x
343x
444x
To search 25, 4 units of time is required
 
 
 
Key=65 P Q m Search
195x
697x
898x
999x
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))

Rajat jain
ADA

time
 
 
 
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
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

Rajat jain
ADA

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

 
 
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.

Rajat jain
ADA

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.
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 ------------

Rajat jain
ADA

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.
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
Multiplicationsequence shifts  

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.

5.1 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 obtainthe 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.

Rajat jain
ADA

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.
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

Rajat jain
ADA

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:

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 filledup 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).
Item chosen Quantity of item Remaining PiXI

Rajat jain
ADA

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 Pi/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 PiXI

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

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 xi’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.

Rajat jain
ADA

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.

 
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

Rajat jain
ADA

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 3 rd 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
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)

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.

Rajat jain
ADA

6.1.1 Cassette filling problem:

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 tjneeded 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.
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.

Rajat jain
ADA

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

Rajat jain
ADA

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

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

Rajat jain
ADA

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.

 
 
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.
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

Rajat jain
ADA

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

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 Vw 45+10 45+inf

Minimum 45 inf

  V6

V1 Vw Inf

V1 V3 V4 V2 V5 Vw 45+inf

Minimum inf

Rajat jain
ADA

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,E 1) of
G is a spanning tree of G if and only if t is a tree.

 
 
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 secondlaw 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

Rajat jain
ADA

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 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.

  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

Rajat jain
ADA

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.
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

Rajat jain
ADA

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
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
beenexplored 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 berepresented using any of the standard queue representations.
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

Rajat jain
ADA

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.

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);
}
 
 

Rajat jain
ADA

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
maximumelements from the max heap a[1..n] can be deleted by deleting
the root of the corresponding 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

Rajat jain
ADA

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];
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 sortingalgorithm 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;
}
}
 

Rajat jain