Cs6402 design and analysis of algorithms may june 2016 answer key

B.E. / B.Tech. DEGREE EXAMINATION, MAY / JUNE 2016
Fourth Semester
Computer Science and Engineering
CS6402 - DESIGN AND ANALYSIS OF ALGORITHM
(Regulation 2013)
PART – A
1. Give the Euclid’s algorithm for computing gcd(m, n)
ALGORITHM Euclid_gcd(m, n)
//Computes gcd(m, n) by Euclid’s algorithm
//Input: Two nonnegative, not-both-zero integers m and n
//Output: Greatest common divisor of m and n
while n ≠ 0 do
r ←m mod n
m←n
n←r
return m
Example: gcd(60, 24) = gcd(24, 12) = gcd(12, 0) = 12.
2. Compare the order of growth n(n-1)/2 and n2
.
n n(n-1)/2 n2
Polynomial Quadratic Quadratic
1 0 1
2 1 4
4 6 16
8 28 64
10 45 102
102
4950 104
Complexity Low High
Growth Low high
n(n-1)/2 is lesser than the half of n2
3. Give the General strategy divide and conquer method.
A divide and conquer algorithm works by recursively breaking down a problem into two
or more sub-problems of the same (or related) type (divide), until these become simple enough to
be solved directly (conquer).
Divide-and-conquer algorithms work according to the following general plan:
1. A problem is divided into several subproblems of the same type, ideally of about equal size.
2. The subproblems are solved (typically recursively, though sometimes a different algorithm
is employed, especially when subproblems become small enough).
3. If necessary, the solutions to the subproblems are combined to get a solution to the original
problem.
Example: Merge sort, Quick sort, Binary search, Multiplication of Large Integers and
Strassen’s Matrix Multiplication.
4. What is Closest-Pair Problem?
The closest-pair problem finds the two closest points in a set of n points. It is the simplest of
a variety of problems in computational geometry that deals with proximity of points in the plane or
higher-dimensional spaces.

5. Define the single source shortest path problem.
Dijkstra’s algorithm solves the single source shortest path problem of finding shortest paths
from a given vertex( the source), to all the other vertices of a weighted graph or digraph.
Dijkstra’s algorithm provides a correct solution for a graph with non negative weights.
6. State Assignment problem.
There are n people who need to be assigned to execute n jobs, one person per job. (That is,
each person is assigned to exactly one job and each job is assigned to exactly one person.) The cost
that would accrue if the ith person is assigned to the jth job is a known quantity 𝐶[𝑖, 𝑗] for each pair
𝑖, 𝑗 = 1, 2, . . . , 𝑛. The problem is to find an assignment with the minimum total cost.
7. What is state space tree?
Backtracking and branch bound are based on the construction of a state space tree, whose nodes
reflect specific choices made for a solution’s component .Its root represents an initial state before
the search for a solution begins. The nodes of the first level the tree represent the made for the first
component of solution, the nodes of the second evel represent the Choices for the second
components & so on
8. State Extreme point theorem.
Any linear programming problem with a nonempty bounded feasible region has an optimal
solution; moreover, an optimal solution can always be found at an extreme point of the problem’s
feasible region.
Extreme point theorem states that if S is convex and compact in a locally convex space, then S
is the closed convex hull of its extreme points: In particular, such a set has extreme points. Convex
set has its extreme points at the boundary. Extreme points should be the end points of the line
connecting any two points of convex set.
9. Give the purpose of lower bound.
 The elements are compared using operator < to make selection.
 Branch and bound is an algorithm design technique that uses lower bound comparisons.
 Main purpose is to select the best lower bound.
 Example: Assignment problem and transportation problem.
10. What is The Euclidean minimum spanning tree problem?
The Euclidean minimum spanning tree or EMST is a minimum spanning tree of a set of n
points in the plane where the weight of the edge between each pair of points is the Euclidean
distance between those two points. In simpler terms, an EMST connects a set of dots using lines
such that the total length of all the lines is minimized and any dot can be reached from any other by
following the lines.
PART – B
11. a. i. Give the definition and Graphical Representation of O-Notation. (8)
Asymptotic notation is a notation, which is used to take meaningful statement about the
efficiency of a program.
The efficiency analysis framework concentrates on the order of growth of an algorithm’s
basic operation count as the principal indicator of the algorithm’s efficiency.
To compare and rank such orders of growth, computer scientists use three notations, they
are:
 O - Big oh notation
 Ω - Big omega notation
 Θ - Big theta notation

Let t(n) and g(n) can be any nonnegative functions defined on the set of natural numbers.
The algorithm’s running time t(n) usually indicated by its basic operation count C(n), and g(n),
some simple function to compare with the count.
O - Big oh notation
A function t(n) is said to be in O(g(n)), denoted 𝑡 (𝑛) ∈ 𝑂(𝑔(𝑛)), if t (n) is bounded above
by some constant multiple of g(n) for all large n, i.e., if there exist some positive constant c and
some nonnegative integer n0 such that
𝑡 (𝑛) ≤ 𝑐𝑔(𝑛) 𝑓𝑜𝑟 𝑎𝑙𝑙 𝑛 ≥ 𝑛0.
Where t(n) and g(n) are nonnegative functions defined on the set of natural numbers.
O = Asymptotic upper bound = Useful for worst case analysis = Loose bound
FIGURE Big-oh notation: 𝑡 (𝑛) ∈ 𝑂(𝑔(𝑛)).
Example 1: Prove the assertions 100𝑛 + 5 ∈ 𝑂(𝑛2
).
Proof: 100n + 5 ≤ 100n + n (for all n ≥ 5)
= 101n
≤ 101n2
(∵ 𝑛 ≤ 𝑛2
)
Since, the definition gives us a lot of freedom in choosing specific values for constants c
and n0. We have c=101 and n0=5
Example 2: Prove the assertions 100𝑛 + 5 ∈ 𝑂(𝑛).
Proof: 100n + 5 ≤ 100n + 5n (for all n ≥ 1)
= 105n
i.e., 100n + 5 ≤ 105n
i.e., t(n) ≤ cg(n)
∴100𝑛 + 5 ∈ 𝑂 𝑛 with c=105 and n0=1
11 (a) (ii) Give an algorithm to check whether all the Elements in a given array of n elements
are distinct. Find the worst case complexity of the same. (8)
Element uniqueness problem: check whether all the Elements in a given array of n elements are
distinct.
ALGORITHM UniqueElements(A[0..n − 1])
//Determines whether all the elements in a given array are distinct
//Input: An array A[0..n − 1]

//Output: Returns “true” if all the elements in A are distinct and “false” otherwise
for i ←0 to n − 2 do
for j ←i + 1 to n − 1 do
if A[i]= A[j ] return false
return true
Worst case Algorithm analysis
 The natural measure of the input’s size here is again n (the number of elements in the array).
 Since the innermost loop contains a single operation (the comparison of two elements), we
should consider it as the algorithm’s basic operation.
 The number of element comparisons depends not only on n but also on whether there are
equal elements in the array and, if there are, which array positions they occupy. We will
limit our investigation to the worst case only.
 One comparison is made for each repetition of the innermost loop, i.e., for each value of the
loop variable j between its limits i + 1 and n − 1; this is repeated for each value of the outer
loop, i.e., for each value of the loop variable i between its limits 0 and n − 2.
(OR)
11 (b) Give the recursive algorithm which finds the number of binary digits in the binary
representation of a positive decimal integer. Find the recurrence relation and complexity. (16)
An investigation of a recursive version of the algorithm which finds the number of binary
digits in the binary representation of a positive decimal integer.
ALGORITHM BinRec(n)
//Input: A positive decimal integer n
//Output: The number of binary digits in n’s binary representation
if n = 1 return 1
else return BinRec( n/2 )+ 1
Algorithm analysis
The number of additions made in computing BinRec( n/2 ) is A( n/2 ), plus one more
addition is made by the algorithm to increase the returned value by 1. This leads to the recurrence
A(n) = A( n/2 ) + 1 for n > 1.
Since the recursive calls end when n is equal to 1 and there are no additions made
then, the initial condition is A(1) = 0.
The standard approach to solving such a recurrence is to solve it only for n = 2k
A(2k
) = A(2k−1
) + 1 for k > 0,
A(20
) = 0.

backward substitutions
A(2k
) = A(2k−1
) + 1 substitute A(2k−1
) = A(2k−2
) + 1
= [A(2k−2
) + 1]+ 1= A(2k−2
) + 2 substitute A(2k−2
) = A(2k−3
) + 1
= [A(2k−3
) + 1]+ 2 = A(2k−3
) + 3 . . .
. . .
= A(2k−i
) + i
. . .
= A(2k−k
) + k.
Thus, we end up with A(2k
) = A(1) + k = k, or, after returning to the original variable n = 2k
and
hence k = log2 n,
A(n) = log2 n ϵ Θ (log2 n).
12 (a) State and Explain Mergesort algorithm and give the recurrence relation and
efficiency (16)
Mergesort is based on divide-and-conquer technique. It sorts a given array A[0..n−1] by
dividing it into two halves A[0.. 𝑛/2 −1] and A[ 𝑛/2 ..n−1], sorting each of them recursively, and
then merging the two smaller sorted arrays into a single sorted one.
ALGORITHM Mergesort(A[0..n − 1])
//Sorts array A[0..n − 1] by recursive mergesort
//Input: An array A[0..n − 1] of orderable elements
//Output: Array A[0..n − 1] sorted in nondecreasing order
if n > 1
copy A[0.. 𝑛/2 − 1] to B[0.. 𝑛/2 − 1]
copy A[ 𝑛/2 ..n − 1] to C[0.. 𝑛/2 − 1]
Mergesort(B[0.. 𝑛/2 − 1])
Mergesort(C[0.. 𝑛/2 − 1])
Merge(B, C, A) //see below
The merging of two sorted arrays can be done as follows. Two pointers (array indices) are
initialized to point to the first elements of the arrays being merged. The elements pointed to are
compared, and the smaller of them is added to a new array being constructed; after that, the index
of the smaller element is incremented to point to its immediate successor in the array it was copied
from. This operation is repeated until one of the two given arrays is exhausted, and then the
remaining elements of the other array are copied to the end of the new array.
ALGORITHM Merge(B[0..p − 1], C[0..q − 1], A[0..p + q − 1])
//Merges two sorted arrays into one sorted array
//Input: Arrays B[0..p − 1] and C[0..q − 1] both sorted
//Output: Sorted array A[0..p + q − 1] of the elements of B and C
i ←0; j ←0; k←0
while i <p and j <q do
if B[i]≤ C[j ]
A[k]←B[i]; i ←i + 1
else A[k]←C[j ]; j ←j + 1
k←k + 1
if i = p

copy C[j..q − 1] to A[k..p + q − 1]
else copy B[i..p − 1] to A[k..p + q − 1]
The operation of the algorithm on the list 8, 3, 2, 9, 7, 1, 5, 4 is illustrated in Figure 2.10.
FIGURE Example of mergesort operation.
The recurrence relation for the number of key comparisons C(n) is
C(n) = 2C(n/2) + Cmerge(n) for n > 1, C(1) = 0.
In the worst case, Cmerge(n) = n − 1, and we have the recurrence
Cworst(n) = 2Cworst(n/2) + n − 1 for n > 1, Cworst(1) = 0.
By Master Theorem, Cworst(n) ∈ Θ(n log n)
the exact solution to the worst-case recurrence for n = 2k
Cworst(n) = n log2 n − n + 1.
For large n, the number of comparisons made by this algorithm in the average case turns out
to be about 0.25n less and hence is also in Θ (n log n).
First, the algorithm can be implemented bottom up by merging pairs of the array’s elements,
then merging the sorted pairs, and so on. This avoids the time and space overhead of using a stack
to handle recursive calls. Second, we can divide a list to be sorted in more than two parts, sort each
recursively, and then merge them together. This scheme, which is particularly useful for sorting
files residing on secondary memory devices, is called multiway mergesort.
(OR)
12 (b) Explain the method used for performing Multiplication of two large integers.
Explain how divide and conquer method can be used to solve the same. (16)
Some applications like modern cryptography require manipulation of integers that are over
100 decimal digits long. Since such integers are too long to fit in a single word of a modern
computer, they require special treatment.

In the conventional pen-and-pencil algorithm for multiplying two n-digit integers, each of
the n digits of the first number is multiplied by each of the n digits of the second number for the
total of n2
digit multiplications.
The divide-and-conquer method does the above multiplication in less than n2
digit
multiplications.
Example: 23 ∗ 14 = (2 · 101
+ 3 · 100
) ∗ (1 · 101
+ 4 · 100
)
= (2 ∗ 1)102
+ (2 ∗ 4 + 3 ∗ 1)101
+ (3 ∗ 4)100
= 2· 102
+ 11· 101
+ 12· 100
= 3· 102
+ 2· 101
+ 2· 100
= 322
The term (2 ∗ 1 + 3 ∗ 4) computed as 2 ∗ 4 + 3 ∗ 1= (2 + 3) ∗ (1+ 4) – (2 ∗ 1) − (3 ∗ 4). Here
(2 ∗ 1) and (3 ∗ 4) are already computed used. So only one multiplication only we have to do.
For any pair of two-digit numbers a = a1a0 and b = b1b0, their product c can be computed by
the formula c = a ∗ b = c2102
+ c1101
+ c0,
where
c2 = a1 ∗ b1 is the product of their first digits,
c0 = a0 ∗ b0 is the product of their second digits,
c1 = (a1 + a0) ∗ (b1 + b0) − (c2 + c0) is the product of the sum of the
a’s digits and the sum of the b’s digits minus the sum of c2 and c0.
Now we apply this trick to multiplying two n-digit integers a and b where n is a positive
even number. Let us divide both numbers in the middle to take advantage of the divide-and-
conquer technique. We denote the first half of the a’s digits by a1 and the second half by a0; for b,
the notations are b1 and b0, respectively. In these notations, a = a1a0 implies that a = a110n/2
+ a0
and b = b1b0 implies that b = b110n/2
+ b0. Therefore, taking advantage of the same trick we used for
two-digit numbers, we get
C = a ∗ b = (a110n/2
+ a0) * (b110n/2
+ b0)
= (a1 * b1)10n
+ (a1 * b0 + a0 * b1)10n/2
+ (a0 * b0)
= c210n
+ c110n/2
+ c0,
where
c2 = a1 * b1 is the product of their first halves,
c0 = a0 * b0 is the product of their second halves,
c1 = (a1 + a0) * (b1 + b0) − (c2 + c0)
If n/2 is even, we can apply the same method for computing the products c2, c0, and c1.
Thus, if n is a power of 2, we have a recursive algorithm for computing the product of two n-digit
integers. In its pure form, the recursion is stopped when n becomes 1. It can also be stopped when
we deem n small enough to multiply the numbers of that size directly.
The multiplication of n-digit numbers requires three multiplications of n/2-digit numbers,
the recurrence for the number of multiplications M(n) is M(n) = 3M(n/2) for n > 1, M(1) = 1.
Solving it by backward substitutions for n = 2k
yields
M(2k
) = 3M(2k−1
)
= 3[3M(2k−2
)]
= 32
M(2k−2
)

= . . .
= 3i
M(2k−i
)
= . . .
= 3k
M(2k−k
)
= 3k
.
(Since k = log2 n)
M(n) = 3log
2
n
= nlog
2
3
≈ n1.585.
(On the last step, we took advantage of the following property of logarithms: alog
b
c
= clog
b
a
.)
Let A(n) be the number of digit additions and subtractions executed by the above algorithm
in multiplying two n-digit decimal integers. Besides 3A(n/2) of these operations needed to compute
the three products of n/2-digit numbers, the above formulas require five additions and one
subtraction. Hence, we have the recurrence
A(n) = 3·A(n/2) + cn for n > 1, A(1) = 1.
By using Master Theorem, we obtain A(n) ∈ Θ(nlog
2
3
),
which means that the total number of additions and subtractions have the same asymptotic
order of growth as the number of multiplications.
Example: For instance: a = 2345, b = 6137, i.e., n=4.
Then C = a * b = (23*102
+45)*(61*102
+37)
C = a ∗ b = (a110n/2
+ a0) * (b110n/2
+ b0)
= (a1 * b1)10n
+ (a1 * b0 + a0 * b1)10n/2
+ (a0 * b0)
= (23 * 61)104
+ (23 * 37 + 45 * 61)102
+ (45 * 37)
= 1403•104
+ 3596•102
+ 1665
= 14391265
13. (a) Discuss about the algorithm and pseudocode to find the Minimum Spanning Tree
using Prim’s Algorithm. Find the Minimum Spanning Tree for the graph shown below. Ans
Discuss about the efficiency of the algorithm. (16)
A spanning tree of an undirected connected graph is its connected acyclic subgraph (i.e., a
tree) that contains all the vertices of the graph. If such a graph has weights assigned to its edges, a
minimum spanning tree is its spanning tree of the smallest weight, where the weight of a tree is
defined as the sum of the weights on all its edges. The minimum spanning tree problem is the
problem of finding a minimum spanning tree for a given weighted connected graph.
ALGORITHM Prim(G)
//Prim’s algorithm for constructing a minimum spanning tree
//Input: A weighted connected graph G = {V, E}
//Output: ET, the set of edges composing a minimum spanning tree of G
VT←{v0} //the set of tree vertices can be initialized with any vertex
ET←Φ
for i ←1 to |V| − 1 do
find a minimum-weight edge e∗ = (v∗, u∗) among all the edges (v, u)
such that v is in VT and u is in V − VT

VT←VT∪ {u*
}
ET←ET∪ {e*
}
return ET
Minimum spanning tree cost = 2+3+1 = 6
Efficiency of the algorithm
If a graph is represented by its adjacency lists and the priority queue is implemented as a
min-heap, the running time of the algorithm is O(|E| log |V |) in a connected graph, where |V| − 1≤
|E|.
(OR)
13. (b) Find all the solution to the traveling salesman problem (cities and distance shown
below) by exhaustive search. Give the optimal solutions. (16)
[--------------------------------UNIT II Question asked in Unit III-------------------------------]
The traveling salesman problem (TSP) is one of the combinatorial problems. The problem asks to
find the shortest tour through a given set of n cities that visits each city exactly once before
returning to the city where it started.
The problem can be conveniently modeled by a weighted graph, with the graph’s vertices
representing the cities and the edge weights specifying the distances. Then the problem can be
stated as the problem of finding the shortest Hamiltonian circuit of the graph. (A Hamiltonian
circuit is defined as a cycle that passes through all the vertices of the graph exactly once).
A Hamiltonian circuit can also be defined as a sequence of n + 1 adjacent vertices
vi0, vi1, . . . , vin−1, vi0, where the first vertex of the sequence is the same as the last one and all the
other n − 1 vertices are distinct. All circuits start and end at one particular vertex. Figure 2.4
presents a small instance of the problem and its solution by this method.
a c
b d
4
6
3
12
a
b
2
a
b d
2
3
a c
b d
3
12

Tour Length
a ---> b ---> c ---> d ---> a I = 2 + 8 + 1 + 7 = 18
a ---> b ---> d ---> c ---> a I = 2 + 3 + 1 + 5 = 11 optimal
a ---> c ---> b ---> d ---> a I = 5 + 8 + 3 + 7 = 23
a ---> c ---> d ---> b ---> a I = 5 + 1 + 3 + 2 = 11 optimal
a ---> d ---> b ---> c ---> a I = 7 + 3 + 8 + 5 = 23
a ---> d ---> c ---> b ---> a I = 7 + 1 + 8 + 2 = 18
FIGURE Solution to a small instance of the traveling salesman problem by exhaustive search.
14. (a) (i) Summarize the Simplex method. (8)
Step 0 [Initialization] Present a given LP problem in standard form and set up initial tableau.
Step 1 [Optimality test] If all entries in the objective row are nonnegative then stop: the tableau
represents an optimal solution.
Step 2 [Find entering variable] Select the most negative entry in the objective row. Mark its
column to indicate the entering variable and the pivot column.
Step 3 [Find departing (leaving) variable] For each positive entry in the pivot column, calculate
the θ-ratio by dividing that row's entry in the rightmost column (solution) by its entry in the
pivot column. (If there are no positive entries in the pivot column then stop: the problem is
unbounded.) Find the row with the smallest θ-ratio, mark this row to indicate the departing
variable and the pivot row.
Step 4 [Form the next tableau] Divide all the entries in the pivot row by its entry in the pivot
column. Subtract from each of the other rows, including the objective row, the new pivot
row multiplied by the entry in the pivot column of the row in question. Replace the label of
the pivot row by the variable's name of the pivot column and go back to Step 1.
Standard form of LP problem
 Must be a maximization problem
 All constraints (except the nonnegativity constraints) must be in the form of linear
equations
 All the variables must be required to be nonnegative
 Thus, the general linear programming problem in standard form with m constraints
and n unknowns (n ≥ m) is
 Maximize c1 x1 + ...+ cn xn
 Subject to ai 1x1+ ...+ ain xn = bi , i = 1,...,m, x1 ≥ 0, ... , xn ≥ 0
Example
maximize 3x + 5y maximize 3x + 5y + 0u + 0v

subject to x + y ≤ 4 subject to x + y + u = 4
x + 3y ≤ 6 x + 3y + v = 6
x≥0, y≥0 x≥0, y≥0, u≥0, v≥0
Variables u and v, transforming inequality constraints into equality constrains, are called slack
variables
14 (a) (ii) State and Prove Maximum Flow Min cut Theorem. (8)
Maximum Flow Problem
Problem of maximizing the flow of a material through a transportation network (e.g.,
pipeline system, communications or transportation networks)
Formally represented by a connected weighted digraph with n vertices numbered from 1 to n
with the following properties:
• Contains exactly one vertex with no entering edges, called the source (numbered 1)
• Contains exactly one vertex with no leaving edges, called the sink (numbered n)
• Has positive integer weight uij on each directed edge (i.j), called the edge capacity,
indicating the upper bound on the amount of the material that can be sent from i to j through
this edge.
A digraph satisfying these properties is called a flow network or simply a network
Flow value and Maximum Flow Problem
Since no material can be lost or added to by going through intermediate vertices of the network, the
total amount of the material leaving the source must end up at the sink:
∑ x1j = ∑ xjn
j: (1,j) є E j: (j,n) є E
The value of the flow is defined as the total outflow from the source (= the total inflow into the
sink). The maximum flow problem is to find a flow of the largest value (maximum flow) for a given
network.
Max-Flow Min-Cut Theorem
1. The value of maximum flow in a network is equal to the capacity of its minimum cut
2. The shortest augmenting path algorithm yields both a maximum flow and a minimum cut:
• Maximum flow is the final flow produced by the algorithm
• Minimum cut is formed by all the edges from the labeled vertices to unlabeled
vertices on the last iteration of the algorithm.
• All the edges from the labeled to unlabeled vertices are full, i.e., their flow amounts
are equal to the edge capacities, while all the edges from the unlabeled to labeled
vertices, if any, have zero flow amounts on them.
(OR)

14 (b)Apply the shortest Augmenting Path algorithm to the network shown below. (16)
Augmenting Path (Ford-Fulkerson) Method
 Start with the zero flow (xij = 0 for every edge).
 On each iteration, try to find a flow-augmenting path from source to sink, which a path
along which some additional flow can be sent.
 If a flow-augmenting path is found, adjust the flow along the edges of this path to get a
flow of increased value and try again.
 If no flow-augmenting path is found, the current flow is maximum.
Augmenting path: 1→2 →3 →6
xij/uij

15. (a) Give any five undecidable problems and explain the famous halting problem. (16)
[-----------------------------------------Out of Syllabus--------------------------------------------]
 Halting Problem.
 Post correspondence problem.
 Hilbert's tenth problem: the problem of deciding whether a Diophantine equation
(multivariable polynomial equation) has a solution in integers.
 Determining if a context-free grammar generates all possible strings, or if it is ambiguous.
 The word problem in algebra and computer science.
 The word problem for certain formal languages.
 Determining whether a λ-calculus formula has a normal form.
In computability theory and computational complexity theory, an undecidable problem is a decision
problem for which it is known to be impossible to construct a single algorithm that always leads to
a correct yes-or-no answer.
Some decision problems cannot be solved at all by any algorithm. Such problems are called
undecidable, as opposed to decidable problems that can be solved by an algorithm. A famous
example of an undecidable problem was given by Alan Turing in 1936.1 The problem in question
is called the halting problem: given a computer program and an input to it, determine whether the
program will halt on that input or continue working indefinitely on it.
Here is a surprisingly short proof of this remarkable fact. By way of contradiction, assume that A is
an algorithm that solves the halting problem. That is, for any program P and input I,
This is a contradiction because neither of the two outcomes for program Q is possible, which
completes the proof.
(OR)
15. (b) State the subset-sum problem and Complete state-space tree of the backtracking
algorithm applied to the instance A={3, 5, 6, 7} and d=15 of the subset-sum problem.
The subset-sum problem finds a subset of a given set A = {a1, . . . , an} of n positive
integers whose sum is equal to a given positive integer d. For example, for A = {1, 2, 5, 6, 8} and
d = 9, there are two solutions: {1, 2, 6} and {1, 8}. Of course, some instances of this problem may
have no solutions.

It is convenient to sort the set’s elements in increasing order. So, we will assume that
a1< a2 < . . . < an.
A = {3, 5, 6, 7} and d = 15 of the subset-sum problem. The number inside a node is the sum
of the elements already included in the subsets represented by the node. The inequality below a leaf
indicates the reason for its termination.
FIGURE 5.15 Complete state-space tree of the backtracking algorithm applied to the instance
Example:
 The state-space tree can be constructed as a binary tree like that in Figure 5.15 for the
instance A = {3, 5, 6, 7} and d = 15.
 The root of the tree represents the starting point, with no decisions about the given elements
made as yet.
 Its left and right children represent, respectively, inclusion and exclusion of a1 in a set being
sought. Similarly, going to the left from a node of the first level corresponds to inclusion of
a2 while going to the right corresponds to its exclusion, and so on.
 Thus, a path from the root to a node on the ith level of the tree indicates which of the first I
numbers have been included in the subsets represented by that node.
 We record the value of s, the sum of these numbers, in the node.
 If s is equal to d, we have a solution to the problem. We can either report this result and stop
or, if all the solutions need to be found, continue by backtracking to the node’s parent.
 If s is not equal to d, we can terminate the node as nonpromising if either of the following
two inequalities holds:
𝑠 + 𝑎i+1 > 𝑑 (the sum s is too large),
s + 𝑎𝑛
𝑗=𝑖+1 j < d (the sum s is too small).
Mr. G. Appasami SET, NET, GATE, M.Sc., M.C.A., M.Phil., M.Tech., (P.hd.), MISTE, MIETE, AMIE, MCSI, MIAE, MIACSIT, MASCAP,
MIARCS, MISIAM, MISCE, MIMS, MISCA, MISAET, PGDTS, PGDBA, PGDHN, PGDST, (AP / CSE / DRPEC).

Cs6402 design and analysis of algorithms may june 2016 answer key

More Related Content

What's hot (20)

Similar to Cs6402 design and analysis of algorithms may june 2016 answer key (20)

More from appasami (20)

Recently uploaded (20)

Cs6402 design and analysis of algorithms may june 2016 answer key