12304 DATA STRUCTURES AND ALGORITHMS

UNIT – V

DYNAMIC PROGRAMMING

Dynamic Programming: Dynamic programming is an algorithm that can be used when

the solution to a problem can be viewed as the result of a sequence of decisions.

In dynamic programming, we examine the decision sequence to see whether an

optimal decision sequence contains optimal decision subsequence.

(1) KNAPSACK PROBLEM

We have already discussed what a Knapsack problem is. Now let us see how to solve
this using dynamic programming.

Given:
• n  Number of objects
• m  Total capacity of the sack
• w[ ]  weights of the objects
• p[ ]  profits of the objects

Aim of the problem:

• Fill the sack up to maximum capacity such that the total profit of selected
objects is maximized.

i =n

∑x
i =1
i p i is maximized

Constraint:
• Total weight of the selected objects should not exceed the maximum
capacity of the sack.

i =n

∑x w
i =1
i i ≤m

where x = { 0.. 1} or x = {0, 1} 0/1 Knapsack problem.

Example:

N = 3, M = 6
W = { 2, 3, 4 }
P = { 1, 2, 5 }

The Knapsack problem using dynamic programming is solved by first generating all the
feasible solutions and then selecting the optimum solution.

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.1

S represents the set of feasible solution for a collection of objects. The set of feasible
solutions is generated using the following technique.

Generation of Feasible solutions:

Si+1 = Si + Si1

Initially no objects are selected and hence the set has only pair (0,0) in the set.

S0 = { (0,0) }; S01 = { (1,2) }

The set S01 is generated by adding (P,W) = (1,2) of the selected object with every pair of
the set S0. Similarly the consecutive sets are generated as follows.

S1 = { (0,0), (1,2) } S11 = { (2,3), (3,5) }

S2 = { (0,0), (1,2), (2,3), (3,5) } S21 = { (5,4), (6,6), (7,7), (8,9) }

S3 = { (0,0), (1,2), (2,3), (5,4), (6,6) }

Now in the last set S3 gives all the possible feasible solutions. From this the solution with
the best value is (6,6) and hence this is the optimal solution.

The objects selected corresponding to the solution (6,6) is found out using the following
technique.

• First find whether (6,6) is present in the previous set S 2. If it is not present then
the third object is selected. The solution of this intermediate stage is (6,6) – (5,4)
= (1,2).
• Now find out whether (1,2) is present in the previous set S1. We find that this is
not present and hence the second object cannot be selected.
• Now find out whether (1,2) is present in the previous set S0. We find that this is
present in that set. Therefore the first object is selected.
• Therefore the final solution is

X={1 0 1}

Algorithm

DKNAPSACK( n, m, w[], p[], x[] )

s[0].p[1] = 0, s[0].w[1] = 0, s[0].c = 1

for i = 1 to n
for j = 1 to s[i-1].c
s[i].p[j] = s[i-1].p[j] + p[i]
s[i].w[j] = s[i-1].w[j] + w[i]
s[i].c = s[i].c + 1

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.2

 end for
s[i] = union(s[i], s[i-1])
s[i].c = s[i].c + s[i-1].c
l = s[i].c
for j = 1 to l
if (s[i].p[j] ≤ s[i].p[j+1] and s[i].w[j] ≥ s[i].w[j+1]) or (s[i].w[j] > m)
delete (s[i].p[j], s[i].w[j])
s[i].c = s[i].c – 1
end if
end for
end for
last = s[n].c
t1 = s[n].p[last], t2 = s[n].p[last]
for i = n to 1
if find( t1, t2 ) = s[i – 1]
x[i] = 0
else
x[i] = 1
t1 = t2 – p[i]
t2 = t2 – w[i]
end if
end for
print x[ ]
end DKNAPSACK

(2) TRAVELING SALESMAN PROBLEM

The traveling salesman problem presents a graph showing n number of cities

which are connected using edges. The cost or distance of each edge is given using the
cost matrix.

Given:
• A graph showing n number of cities connected by edges.
• Cost of each edge is given using the cost matrix.

Aim of the problem:

Find the shortest path to cover all the cities and come back to the same city.

Constraints:

• All the cities should be covered.

• Each city should be visited only once.
• The starting and the ending point should be the same.

Solution:

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.3

 1) Find all possible feasible solutions by taking the permutation of the cities which is
to be covered. By this all possible paths connecting the cities and satisfying the
constraints are generated.
2) Find the cost of each path using the cost matrix.
3) Find out the path with minimum cost. That is selected as the optimum solution.

Example:

Consider the following example. There are 4 cities given. These are connected with
edges as shown. The cost of the edges are shown.

The cost matrix for the given graph is

1 2 3 4

1 0 20 5 10

2 20 0 15 25

3 5 15 0 5

4 10 25 5 0

Let us start visiting from the node 1. Then the remaining 3 cites are 2, 3 and 4. By
applying the permutation function we generate the following possible paths.

1 2 3 4 1  50
1 2 4 3 1  55
1 3 2 4 1  55
1 3 4 2 1  55
1 4 2 3 1  55
1 4 3 2 1  50

Now calculate the cost of each path and select the minimum of these. If there more than
one path having the same cost, then first occurring path is selected.

As per the results shown above, the shortest path selected is the first path.

Therefore the final solution may be,

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.4

 1 2 3 4 1

The cost of the path is 50

Algorithm

TRAVEL(cost[ ], n )

x=2
for s = 1 to n – 1
list[s] = x
x=x+1
end for

for i = 1 to (n – 1)!
for j = 2 to n
path[i][j] = perm(list)
path[i][j] = path[i][n] = 1
pathcost[i] = 0
end for
end for

for i = 1 to (n-1)!
for j = 1 to n
pathcost[i] = pathcost[i] + cost[path[i][j]][path[i][j+1]]
end for
end for

min = 0, minpos = 0
for i = 1 to (n-1)!
If pathcost[i] < min
min = pathcost[i]
minpos =i
end if
end for

print “Shortest path is” path[minpos][ ]

print “Shortest path cost is” pathcost[i]

end Travel

Program

//Travelling Salesman problem using Dynamic Programming

#include <iostream.h>
#include <conio.h>

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.5

class dynamic
{
private:
int n, r, c[5][5], d[24], p[24][6], list[5];
public:
dynamic();
void getdata();
void display();
int fact(int num);
int min(int list[]);
void perm(int list[], int k, int m);
void sol();
};

dynamic::dynamic()
{
r=0;
for (int i=0;i<n;i++)
for (int j=0;j<n;j++)
c[i][j]=0;
}

void dynamic::getdata()
{
cout<<"Enter no. of cities:";
cin>>n;
cout<<endl;
for (int i=0;i<n;i++)
{
for (int j=0;j<n;j++)
{
if (i!=j)
{
if (c[i][j]==0)
{
cout<<"Enter cost from "<<i<<" to "<<j<<" :";
cin>>c[i][j];
c[j][i]=c[i][j];
}
}
}
}
for (i=0;i<n-1;i++)
list[i]=i+1;
}

int dynamic::fact(int num)

{
int f=1;
if (num!=0)
Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.6
for (int i=1;i<=num;i++)
f=f*i;
return f;
}

void dynamic::perm(int list[], int k, int m)

{
int i,temp;
if (k==m)
{
for (i=0;i<=m;i++)
{
p[r][i+1]=list[i];
}
r++;
}
else
for (i=k;i<=m;i++)
{
temp=list[k]; list[k]=list[i]; list[i]=temp;
perm(list,k+1,m);
temp=list[k]; list[k]=list[i]; list[i]=temp;
}
}

void dynamic::sol()
{

perm(list,0,n-2);
for (int i=0;i<fact(n-1);i++)
{
p[i][0]=0;
p[i][n]=0;
}
for (i=0;i<fact(n-1);i++)
{
d[i]=0;
for (int j=0;j<n;j++)
{
d[i]=d[i]+c[p[i][j]][p[i][j+1]];
}
}
}

int dynamic::min(int list[])

{
int minimum=list[0];
for (int i=0;i<(n-1);i++)
{
if (list[i]<minimum)
Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.7
 minimum=list[i];
}
return minimum;
}

void dynamic::display()
{
int i,j;
cout<<endl<<"The cost Matrix:"<<endl;
for (i=0;i<n;i++)
{
for (j=0;j<n;j++)
cout<<c[i][j]<<"\t";
cout<<endl;
}
cout<<endl<<"The Possible paths and their corresponding cost:"<<endl;
for (i=0;i<fact(n-1);i++)
{
for (j=0;j<n+1;j++)
cout<<p[i][j]<<"\t";
cout<<"--> "<<d[i]<<endl;
}
cout<<endl<<"The shortest path :"<<endl;
for (i=0;i<fact(n-1);i++)
{
if (d[i]==min(d))
break;
}
for (j=0;j<=n;j++)
{
cout<<p[i][j]<<" ";
}
cout<<endl<<"\nThe cost of this path is "<<d[i]<<endl;
}

void main()
{
clrscr();

dynamic ts;
ts.getdata();
ts.sol();
ts.display();
getch();
}

Output

Enter no. of cities:4

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.8

Enter cost from 0 to 1 :30
Enter cost from 0 to 2 :6
Enter cost from 0 to 3 :4
Enter cost from 1 to 2 :5
Enter cost from 1 to 3 :10
Enter cost from 2 to 3 :20

The cost Matrix:

0 30 6 4
30 0 5 10
6 5 0 20
4 10 20 0

The Possible paths and their corresponding cost:

0 1 2 3 0 --> 59
0 1 3 2 0 --> 66
0 2 1 3 0 --> 25
0 2 3 1 0 --> 66
0 3 2 1 0 --> 59
0 3 1 2 0 --> 25

The shortest path :

02130

The cost of this path is 25

BACKTRACKING METHOD

Backtracking is a systematic way to search for the solution to a problem.

In Backtracking method,

• We begin by defining a solution space for the problem. The solution space is
the collection all possible solutions to the given problem. The solution space
is usually represented as a tree or a graph.
• Organize solution space so that it can be easily searched.
• Once we have defined an organization for the solution space, this is searched
in a depth first manner (DFS).
• During the search if infeasible solution is sensed then backtrack to previous
node.
• The search terminates when we have found the answer.

(1) KNAPSACK PROBLEM

We have already discussed about the knapsack problem. Let us see how to solve
this using the backtracking method.
In this method a solution space is defined for the knapsack problem as shown.

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.9

This solution space consists of all feasible solutions. Now we have to find out which is
the feasible solution among this. A Depth First Search Traversal is applied on this
solution tree. If an object is selected, then we travel towards the left child as the left edge
carries cost 1 indicating the object is selected. If at any stage of the solution, it is found
that the constraint is not satisfied, then we backtrack to the previous node and go to the
right child indicating that the particular object is not selected. The algorithm stops when
a leaf node is reached.

Given:
• n  Number of objects
• m  Total capacity of the sack
• w[ ]  weights of the objects
• p[ ]  profits of the objects

Aim of the problem:

• Fill the sack up to maximum capacity such that the total profit of selected
objects is maximized.

i =n

∑x
i =1
i p i is maximized

Constraint:
• Total weight of the selected objects should not exceed the maximum
capacity of the sack.

i =n

∑x w
i =1
i i ≤m

where x = { 0.. 1} or x = {0, 1} 0/1 Knapsack problem.

Example:

N = 3, M = 6
W = { 2, 3, 4 }
P = { 1, 2, 5 }

Solution:

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.10

Since there are 3 objects, construct a tree with maximum level = 3 as shown.

Initially we are in level 0 of the solution space. Select the first object. Since the first
object is selected, we move towards the left child of current node. Now we have moved
to level 1. Compare the weight of the object selected with the available capacity of the
sack.

2<6

Remaining capacity  6 – 2 = 4
Therefore so far the solution is correct. Now select the second object which has a weight
3 and move towards the left child of the current node. Now we have moved to level 2.
Compare the weight of the object selected with the available capacity of the sack.

3<4

Remaining capacity  4 – 3 = 1
Now select the third object which has weight 4 and move towards the left child of the
current node. Now we have moved to level 3. Compare the weight of this object with
the available capacity.

4>1

The weight of the object exceeds the available capacity. This leads to an infeasible
solution. Therefore backtrack to previous node which is in level 2. Move towards the
right child indicating that the third object is not selected.

As we have reached the leaf node with a feasible solution, the algorithm comes to an end.

The final solution is therefore

X = { 1, 1, 0 }

Algorithm

BKNAPSACK( k, cp, cw)

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.11

If k > n
Return
End if
If cw + w[k] ≤ m
x[k] = 1
cw = cw + w[k]
cp = cp + p[k]
KNAPSACK( k + 1, cp, cw )
Else
x[k] = 0
KNAPSACK( k + 1, cp, cw )
End if

End KNAPSACK

(2) 8 QUEENS PROBLEM

The solution for the 8 queens problem is easily obtained using the backtracking
algorithm.

Given,

• An 8 X 8 matrix representing a chessboard.

• 8 queens

Aim of the problem:

Place 8 queens on the chessboard in such a way that none of the queens hit each other.

Constraint:

• No two queens should be in the same column.

• No two queens should be in the same diagonal.

Solution:

If a queen is placed in position (i, j ). Now a new queen is placed in the position (k, l)
then the two queens are said to be in the same diagonal if following conditions are
satisfied.
i+j=k+l
i–j=k–l

The above two equations can be rearranged as follows:

i–k=l–j
i–k=j–l
Combining the above two equations,

Abs(i – k) = Abs(j – l)

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.12

Abs indicates the absolute value. If this condition is true, then the queens are in the same
diagonal. To check whether the queens are in the same column we just check whether
j = l.

Now queens are placed one by one in the chessboard by checking the above conditions.
If at any stage we are unable to place a queen, then we have to backtrack and change the
position of the previous queen. This is repeated till we place all the 8 queens on the
board.

The algorithm Place checks and tells whether the new position of the queen is correct or
not. If it is correct, then it returns true otherwise it returns false.

Example:

We try to place the queens as shown.

Solution is:

1 5 8 6 3 7 2 4

Algorithm

PLACE( k, L )

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.13

For i = 1 to k – 1
If x[i] = L or ABS(x[i] – l ) = ABS( i – k )
Return FALSE
End if
End for
Return TRUE

NQUEEN( k, n )

For i = 1 to n
If PLACE( k, i ) = TRUE
x[k] = i
if k = n
print x[ ]
else
NQUEEN( k + 1, n )
End if
End if
End for
End NQUEEN

Program

//8 Queens problem solution using backtracking method

#include <iostream.h>
#include <conio.h>
#include <stdlib.h>

class queen
{
private:
int x[9];
public:
int place(int k, int i);
void eightqueen(int k);
};

int queen::place(int k, int i)

{
for (int j=1; j<k; j++)
if ((x[j]==i) || (abs(x[j]-i)==abs(j-k)))
return 0;
return 1;
}

void queen::eightqueen(int k)
{

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.14

 for (int i=1; i<=8; i++)
{
if (place(k,i)==1)
{
x[k]=i;
if (k==8)
{
for (int j=1; j<=8; j++)
cout<<x[j]<<"\t";
cout<<endl;
}
else
eightqueen(k+1);
}
}
}

void main()
{
clrscr();
queen q;
q.eightqueen(1);
getch();
}

Output

1 5 8 6 3 7 2 4
1 6 8 3 7 4 2 5
1 7 4 6 8 2 5 3
1 7 5 8 2 4 6 3

BRANCH AND BOUND METHOD

The branch and bound method is similar to the backtracking method except that,
this method searches the nodes of the solution space in the Breadth First Search method.
This braches to various nodes in search of the solution, but if an infeasible solution is
encountered, then we bound back and try the next adjacent branch.

(1) TRAVELING SALESMAN PROBLEM

We have already solved this problem using the dynamic programming method.
Now let us see how to solve this problem using branch and bound technique.
Given:
• A graph showing n number of cities connected by edges.
• Cost of each edge is given using the cost matrix.

Aim of the problem:

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.15

 Find the shortest path to cover all the cities and come back to the same city.

Constraints:

• All the cities should be covered.

• Each city should be visited only once.
• The starting and the ending point should be the same.

Solution:

The given graph is the solution space for this problem. Hence we perform a BFS
in this graph to find the solution.
Start from node 1.
• Find all the adjacent nodes of the current node.
• Select the node which is not yet visited and has a least cost edge.
• Move to the selected node and repeat the above steps.
The solution is obtained when al the nodes are visited and we come back to the same city.

Example:

The cost matrix for the given graph is

1 2 3 4

1 0 20 5 10

2 20 0 15 25

3 5 15 0 5

4 10 25 5 0

In the given graph, we start from node 1. The adjacent nodes of 1 are 2, 3, and 4. But we
select node 3 as it has the minimum cost edge. Move to node 3. Repeat the process till
we reach the node 1.

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.16

Therefore the solution to the above problem is
The shortest path  1 3 4 2 1
The cost of the path is 55.

Algorithm

BBTRAVEL( cost[ ], n )

u = city 1
Repeat while(all cities visited)
Find all cities w adjacent from u
If (cost of edge is minimum ) and (city not yet visited)
Move to that city and mark it visited
u = current city
End if
End Repeat
Calculate path cost
Print Shortest path and its cost
End TRAVEL

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.17

(2) COTAINER LOADING PROBLEM

We have already solved this problem using Greedy approach. Now let us use
branch and bound technique to solve this problem. In this problem, there is a ship with
capacity m. The number of containers n is given and their respective weights are also
given. The containers should be loaded in such a way that we load maximum number of
containers in the ship and the total weight of the containers loaded into the ship does not
exceed the capacity of the ship.

Given:
n = Number of containers
w[ ] = Weights of the containers
m = Total capacity of the ship

Aim of the problem:

Load the containers into the ship in such a way that the maximum number of
containers is loaded.

∑x
i =1
i is maximized.

Constraints:
The total weight of the containers loaded should not exceed the capacity of the
ship.

∑x w
i =1
i i ≤m

Solution:
• Develop a solution space, which is represented as tree with left child indicating
that the container is selected and the right child indicating that the container is not
selected.

• Initially we are in the root node. We branch towards the left child and check
whether the container weight is lesser than or equal to the available capacity. If
not, that is a infeasible solution and hence we bound back and select the next
adjacent branch. But if the solution is feasible at that stage, we continue selecting
the next container.

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.18

 • This is repeated till either the number of containers exhausted or the ship capacity
has been filled.

Example:

Let the three containers given has weight as given:

w = { 20, 40, 50 }

Let the ship capacity be 70.

Start from the root node. Select the first container by moving to the left child. Compare
the weight of the first container with the remaining capacity of the ship.

20 < 70

Remaining capacity = 70 – 20 = 50

Now select the second container by branching towards the left child. Compare the
weight of the container with the available capacity of the ship.

40 < 50

Remaining capacity = 10

Now select the third container by branching towards the left child. Compare the weight
of the container with the available capacity of the ship

50 > 10

As the capacity of the container exceeds the capacity of the ship, bound back and go to
adjacent branch. As the leaf node is reached and the solution is a feasible solution, the
algorithm stops here.

The final solution is x = { 1, 1, 0 }

-------End of Unit V------

Prepared by: Sugumaran M, Lecturer, Sathyabama Deemed University 5.19