DATE:

EX.NO:1.A) RECURSIVE ALGORITHM

AIM:
To implement the recursive algorithm for finding factorial of a number using python.

ALGORITHM:
STEP1: start the
program.STEP2: get the
number.
STEP3: if number is equal to 1 return 1 other wise call recursively the factorial
function.
STEP4: return the factorial value
STEP5: print the factorial as the output.
PROGRAM:

def factorial(x):
"""This is a recursive function to find the factorial of an integer"""

if x == 1:
return 1
else:
return (x * factorial(x-1))

num = 5
print("The factorial of", num, "is", factorial(num))

OUTPUT:
120

RESULT:
DATE:
EX.NO: 1.B) NON RECURSIVE ALGORITHM

AIM:
To implement the Non-recursive algorithm using python.

ALGORITHM:
Step1. Read a number
Step2. Initialize fact as 1
Step3. If number is greater than 0, calculate factorial and decrement by 1.
Step4. Print the factorial value.
PROGRAM:

n=int(input("Enter number:"))
fact=1
while(n>0):
fact=fact*n
n=n-1
print("Factorial of the number is: ")
print(fact)

OUTPUT:

Enter number:6
Factorial of the number is:
720

RESULT:
PROGRAM:

graph = {"A":["D","C","B"], "B":["E"], "C":["G","F"], "D":["H"], "E":["I"], "F":["J"]}

def dfs_non_recursive(graph, source):

if source is None or source not in graph:
return "Invalid input"
path = []
stack = [source]
while(len(stack) != 0):
s = stack.pop()
if s not in path:
path.append(s)
if s not in graph:
#leaf node
continue
for neighbor in graph[s]:
stack.append(neighbor)
return " ".join(path)

DFS_path = dfs_non_recursive(graph, "A")

print(DFS_path)

OUTPUT:

ABEICFJGDH

RESULT:
DATE:
EX.NO:2 DIVIDE AND CONQUER-STRASSEN’S MATRIX MULTIPLICATION

AIM:
To implement the strassen’s matrix multiplication using python.

ALGORITHM
Step1. Start the program.
Step2. Divide the matrices A and B into smaller submatrices of the size
n/2xn/2.Step3. Using the formula to carry out 2*2 matrix multiplication.
Step4. In this eight multiplications and four additions, subtractions are
performed. Step5. Combine the result of two matrices to find the final
product or final matrix.Step6. Stop the program.
PROGRAM:

import numpy as
npdef
split(matrix):
row,col=matrix.shape
row2,col2=row//2,col
/2
return
matrix[:row2,:col2],matrix[:row2,col2:],matrix[row2:,col2],matrix[row:,col2:]
def Strassen(x,y):
if lex(x)==1:
return x*y
a,b,c,d=split(
x)
e,f,g,h=split(y)
p1=strassen(a,f-1)
p2=strassen(a+b,h)
p3=strassen(c+d,e)
p4=strassen(d,g-e)
p5=strassen(a+d,e+
h)p6=strassen(b-
d,g+h)
p7=strassen(a-
c,e+f) c11=p5+p4-
p2+p6 c12=p1+p2
c21=p3+p4
c22=p1+p5-p3-p7
c=np.vstack((np.hstack((c11,c12)),hp.hstack((c21,c22))))
return c
OUTPUT:
Array A =>
1 1 1 1
2 2 2 2
3 3 3 3
2 2 2 2
Array B =>
1 1 1 1
2 2 2 2
3 3 3 3
2 2 2 2
Result Array =>
8 8 8 8
16 16 16 16
24 24 24 24
16 16 16 16

RESULT:
DATE:
EX.NO: 3.A) TOPOLOGICAL SORTING

AIM:
To implement the selection sort using python.

ALGORITHM:

Step1.Identify the node that has no in-degree (no incoming edges) and select that
node as thesource node of the graph.
Step2.Delete the source node with zero in-degree and also delete all its outgoing
edges from thegraph. Insert the deleted vertex in the result array.
Step3.Update the in-degree of the adjacent nodes after deleting the
outgoing edgesStep4.Repeat step 1 to step 3 until the graph is empty.
PROGRAM:

#Python program to print topological sorting of a DAG

from collections import defaultdict

#Class to represent a graph

class Graph:
def __init__(self,vertices):
self.graph = defaultdict(list) #dictionary containing adjacency List
self.V = vertices #No. of vertices

# function to add an edge to graph

def addEdge(self,u,v):
self.graph[u].append(v)

# A recursive function used by topologicalSort

def topologicalSortUtil(self,v,visited,stack):

# Mark the current node as visited.

visited[v] = True

# Recur for all the vertices adjacent to this vertex

for i in self.graph[v]:
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)

# Push current vertex to stack which stores result

stack.insert(0,v)

# The function to do Topological Sort. It uses recursive

# topologicalSortUtil()
def topologicalSort(self):
# Mark all the vertices as not visited
visited = [False]*self.V
stack =[]

# Call the recursive helper function to store Topological

# Sort starting from all vertices one by one
for i in range(self.V):
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)

# Print contents of stack

print (stack)
g= Graph(6)
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);

print ("Following is a Topological Sort of the given graph")

g.topologicalSort()

OUTPUT:

Following is a Topological Sort of the given graph

[5, 4, 2, 3, 1, 0]

RESULT:
DATE:
EX.NO:4 TRANSFORM AND CONQUER -HEAP SORT

AIM:
To implement the Heapsort using python.

ALGORITHM:
Step1. Define a function heapify().
Step2. Pass three parameters array,a
and b. Step3. Find largest among root and
children.
Step4. If the root is not the largest,swap it with the
children.Step5. Continue to heapify.
Step6. Define function
Heap_Sort().Step7. Pass array as
parameters.
Step8. Build Max-heap and swap.
PROGRAM:

def heapify(arr, n, i):

largest = i # Initialize largest as root
l = 2 * i + 1 # left = 2*i + 1
r = 2 * i + 2 # right = 2*i + 2

# See if left child of root exists and is

# greater than root

if l < n and arr[i] < arr[l]:

largest = l

# See if right child of root exists and is

# greater than root

if r < n and arr[largest] < arr[r]:

largest = r

# Change root, if needed

if largest != i:
(arr[i], arr[largest]) = (arr[largest], arr[i]) # swap

# Heapify the root.

heapify(arr, n, largest)

# The main function to sort an array of given size

def heapSort(arr):
n = len(arr)

# Build a maxheap.
# Since last parent will be at ((n//2)-1) we can start at that location.

for i in range(n // 2 - 1, -1, -1):

heapify(arr, n, i)

# One by one extract elements

for i in range(n - 1, 0, -1):

(arr[i], arr[0]) = (arr[0], arr[i]) # swap
heapify(arr, i, 0)
# Driver code to test above

arr = [12, 11, 13, 5, 6, 7, ]

heapSort(arr)
n = len(arr)
print('Sorted array is')
for i in range(n):
print(arr[i])

OUTPUT:
Sorted array
is5 6 7 11 12
13

RESULT:
DATE:
EX.NO:5 A) DYNAMIC PROGRAMMING-COIN CHANGE PROBLEMAIM:

To implement the coin change problem using python.

ALGORITHM:
Step1. Start the program.
Step2. Two choices for a coin of a particular denominator either to include or to exclude.
Step3. At coins[n-1], we can take as , any instances of that can ie , count(coins ,n,
sum-coins[n- i])then we can move to coins[n-2].
Step4. After moving to coins [n-2], we can’t move back and can’t make choices for
coins [n-1]ie, count (coins , n-1 , sum).
Step5. Find the total number of ways , to we will add these – possible choices. ie)
count(coins ,n ,sum-coins[n-1])+ count(coins , n-1 ,sum ).
Step6. Stop the program.

PROGRAM:
def count(S, target):
 # if the total is 0, return 1
if target == 0:
return 1
# return 0 if total becomes negative
if target < 0:
return 0
# initialize the total number of ways to 0
result = 0
# do for each coin
for c in S:
# recur to see if total can be reached by including current coin `c`
result += count(S, target - c)

# return the total number of ways

return result

if __name__ == '__main__':

# `n` coins of given denominations

S = [1, 2, 3]
# total change required
target = 4
print('The total number of ways to get the desired change is', count(S, target))

OUTPUT:
The total number of ways to get the desired change is 7

RESULT:
DATE:
EX.NO.5 B) DYNAMIC PROGRAMMING-WARSHALL’S AND FLOYD’S ALGORITHM

AIM:

To implement the Warshall’s and Floyd’s algoritm using python.

ALGORITHM:

Step1. Start the program.

Step2. Create a matrix A0 of dimension n*n where n is the number of vertices.
Step3. Now , create a matrix A1 using matrix A0 . The elements in the first column
and thefirst row left as the are (A[i][k]+A[k][j])if (A[i][j]>A[i][k]+A[k][j].
Step4. Similarly,A2 is created using A1 and similarly A3 and A4 is also
created.Step5. A4 gives the shortest path between each pair of vertices.
Step6. Stop the program.
PROGRAM:

# The number of vertices

nV = 4
INF = 999
# Algorithm implementation
def floyd_warshall(G):
distance = list(map(lambda i: list(map(lambda j: j, i)), G))

# Adding vertices individually

for k in range(nV):
for i in range(nV):
for j in range(nV):
distance[i][j] = min(distance[i][j], distance[i][k] + distance[k][j])
print_solution(distance)
# Printing the solution
def print_solution(distance):
for i in range(nV):
for j in range(nV):
if(distance[i][j] == INF):
print("INF", end=" ")
else:
print(distance[i][j], end=" ")
print(" ")
G = [[0, 3, INF, 5],
[2, 0, INF, 4],
[INF, 1, 0, INF],
[INF, INF, 2, 0]]
floyd_warshall(G)

OUTPUT:

0 3 7 5

2 0 6 4

3 1 0 5

5 3 2 0

RESULT:
DATE:
EX.NO.5 (C) DYNAMIC PROGRAMMING-KNAPSACK PROBLEMAIM:

To implement the Knapsack problem using python.

ALGORITHM:

Step1. Start the program.

Step2. Maximum value obtained by n-1 items and W weight.
Step3. Vlaue of n th item plus maximum value obtained by n-1 items and W minus the
weight ofn th item.
Step4. If the weight of ‘n th’ item is greater than ‘W’ then the n th item cannot be
installed.Step5. Stop the program.

PROGRAM:
def knapSack(W, wt, val, n):
K = [[0 for x in range(W + 1)] for x in range(n + 1)]

# Build table K[][] in bottom up manner

for i in range(n + 1):
for w in range(W + 1):
if i == 0 or w == 0:
K[i][w] = 0
elif wt[i-1] <= w:
K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w])
else:
K[i][w] = K[i-1][w]

return K[n][W]

# Driver program to test above function

val = [60, 100, 120]
wt = [10, 20, 30]
W = 50
n = len(val)
print(knapSack(W, wt, val, n))

OUTPUT:

220

RESULT:
DATE:
EX.NO 6.A) GREEDY TECHNIQUES- DIJKSTRA’S ALGORITHM

AIM:
To implement Dijkstra’s algorithm using python.

ALGORITHM:
Step1. Initialize the distance from the source node S to all other nodes as infinite
and to itselfas 0.
Step2. Insert the pair of node, distance for source i.e S, 0 in a DICTIONARY
Step3. While the DICTIONARY is not empty do
Step4. current_source_node = DICTIONARY . get_key (node)_with_smallest_value
(dist)Step5. Remove the key (current_source_node) from the DICTIONARY.
Step6. For every adjacent_node to the
current_source_node doStep7. If ( distance
[ adjacent_node ] &gt;
Step8. length_of_path_to_adjacent_node_from_current_source +
distance[ current_source_node ] )
Step9. distance[adjacent_node ] =length_of_path_to_adjacent_node_from_current_source
+distance[ current_source_node ]
Step10. Update the DICTIONARY with the new pair &lt; adjacent_node,
distance [adjacent_node ] &gt;
PROGRAM:

from collections import defaultdict

class Node_Distance :

def __init__(self, name : int, dist : int) :

self.name = name
self.dist = dist

class Graph :

def __init__ (self, node_count : int) :

self.adjlist = defaultdict(list)
self.node_count = node_count

def Add_Into_Adjlist (self, src : int, node_dist : Node_Distance(int,int)) :

self.adjlist[src].append(node_dist)

def Dijkstras_Shortest_Path (self, source : int) :

# Initialize the distance of all the nodes from the source node to infinity
distance = [999999999999] * self.node_count
# Distance of source node to itself is 0
distance[source] = 0

# Create a dictionary of { node, distance_from_source }

dict_node_length = {source: 0}
while dict_node_length :

# Get the key for the smallest value in the dictionary

# i.e Get the node with the shortest distance from the source
current_source_node = min(dict_node_length, key = lambda k: dict_node_length[k])
del dict_node_length[current_source_node]

for node_dist in self.adjlist[current_source_node] :

adjnode = node_dist.name
length_to_adjnode = node_dist.dist

# Edge relaxation
if distance[adjnode] > distance[current_source_node] + length_to_adjnode :
distance[adjnode] = distance[current_source_node] + length_to_adjnode
dict_node_length[adjnode] = distance[adjnode]

for i in range(self.node_count) :
print("Source Node ("+str(source)+") -> Destination Node(" + str(i) + ") : " +
str(distance[i]))

def main() :
 g = Graph(6)

# Node 0: <1,5> <2,1> <3,4>

g.Add_Into_Adjlist(0, Node_Distance(1, 5))
g.Add_Into_Adjlist(0, Node_Distance(2, 1))
g.Add_Into_Adjlist(0, Node_Distance(3, 4))

# Node 1: <0,5> <2,3> <4,8>

g.Add_Into_Adjlist(1, Node_Distance(0, 5))
g.Add_Into_Adjlist(1, Node_Distance(2, 3))
g.Add_Into_Adjlist(1, Node_Distance(4, 8))

# Node 2: <0,1> <1,3> <3,2> <4,1>

g.Add_Into_Adjlist(2, Node_Distance(0, 1))
g.Add_Into_Adjlist(2, Node_Distance(1, 3))
g.Add_Into_Adjlist(2, Node_Distance(3, 2))
g.Add_Into_Adjlist(2, Node_Distance(4, 1))

# Node 3: <0,4> <2,2> <4,2> <5,1>

g.Add_Into_Adjlist(3, Node_Distance(0, 4))
g.Add_Into_Adjlist(3, Node_Distance(2, 2))
g.Add_Into_Adjlist(3, Node_Distance(4, 2))
g.Add_Into_Adjlist(3, Node_Distance(5, 1))

# Node 4: <1,8> <2,1> <3,2> <5,3>

g.Add_Into_Adjlist(4, Node_Distance(1, 8))
g.Add_Into_Adjlist(4, Node_Distance(2, 1))
g.Add_Into_Adjlist(4, Node_Distance(3, 2))
g.Add_Into_Adjlist(4, Node_Distance(5, 3))

# Node 5: <3,1> <4,3>

g.Add_Into_Adjlist(5, Node_Distance(3, 1))
g.Add_Into_Adjlist(5, Node_Distance(4, 3))

g.Dijkstras_Shortest_Path(0)
print("\n")
g.Dijkstras_Shortest_Path(5)

if __name__ == "__main__" :
main()
OUTPUT:

Source Node (0) -> Destination Node(0) :0

Source Node (0) -> Destination Node(1) :4
Source Node (0) -> Destination Node(2) :1
Source Node (0) -> Destination Node(3) :3
Source Node (0) -> Destination Node(4) :2
Source Node (0) -> Destination Node(5) :4

Source Node (5) -> Destination Node(0) :4

Source Node (5) -> Destination Node(1) :6
Source Node (5) -> Destination Node(2) :3
Source Node (5) -> Destination Node(3) :1
Source Node (5) -> Destination Node(4) :3
Source Node (5) -> Destination Node(5) :0

RESULT:
DATE:
EX.NO:6. B) HUFFMAN TREES AND CODES

AIM:
To implement the Huffmann trees and codes using python.

ALGORITHM:
Step1. Calculate the frequency of each character in the string.
Step2. Sort the characters in increasing order of the frequency.
Step3. Make each unique character as a leaf node.
Step4. Create an empty node. Assign the minimum frequency to the left child of empty node
and assign the second minimum frequency to the right child of empty node . Set the
value of the empty node as the sum of the above two minimum frequencies.
Step5. Remove these two minimum frequencies from list and add the sum into the list of
frequencies.
Step6. Insert node into the tree.
Step7. Repeat steps 3 to 5 for all the characters.
Step8. For each non-leaf node, assign 0 to the left edge and 1 to the right edge.
PROGRAM:

# A Huffman Tree Node

import heapq
class node:
def __init__(self, freq, symbol, left=None, right=None):
# frequency of symbol
self.freq = freq

# symbol name (character)

self.symbol = symbol

# node left of current node

self.left = left

# node right of current node

self.right = right

# tree direction (0/1)

self.huff = ''

def __lt__(self, nxt):

return self.freq < nxt.freq

# utility function to print huffman

# codes for all symbols in the newly
# created Huffman tree
def printNodes(node, val=''):

# huffman code for current node

newVal = val + str(node.huff)

# if node is not an edge node

# then traverse inside it
if(node.left):
printNodes(node.left, newVal)
if(node.right):
printNodes(node.right, newVal)

# if node is edge node then

# display its huffman code
if(not node.left and not node.right):
print(f"{node.symbol} -> {newVal}")

# characters for huffman tree

chars = ['a', 'b', 'c', 'd', 'e', 'f']

# frequency of characters
freq = [ 5, 9, 12, 13, 16, 45]
# list containing unused nodes
nodes = []

# converting characters and frequencies

# into huffman tree nodes
for x in range(len(chars)):
heapq.heappush(nodes, node(freq[x], chars[x]))

while len(nodes) > 1:

# sort all the nodes in ascending order

# based on their frequency
left = heapq.heappop(nodes)
right = heapq.heappop(nodes)

# assign directional value to these nodes

left.huff = 0
right.huff = 1

# combine the 2 smallest nodes to create

# new node as their parent
newNode = node(left.freq+right.freq, left.symbol+right.symbol, left, right)

heapq.heappush(nodes, newNode)

# Huffman Tree is ready!

printNodes(nodes[0])

OUTPUT:
f -> 0
c -> 100
d -> 101
a -> 1100
b -> 1101
e -> 111

RESULT:
DATE:
EX.NO:7 ITERATIVE IMPROVEMENT-SIMPLEX METHOD

AIM:To implement Iterative improvement in simplex method using python.

ALGORITHM:
Step1.Standard form.
Step2.Determine stack
variable.Step3.Setting up the
tableau.
Step4.Check optimality.
Step5.Identify pivot .
Step6.Create the new
tableau.Step7.Check
optimality.
Step8. Identify new pivot
variable.Step9.rom simplex
import simplex
PROGRAM:
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0,20,10000)
y1 = 11.0 + x
y2 = 27.0 - x
y3 = (90-2*x)/5.0
plt.plot(x,y1,label = r'$-x+y\leq11$')
plt.plot(x,y2,label = r'$x+y\leq27$')
plt.plot(x,y3,label = r'$2x+5y\leq90$')
#plt.xlim((0, 20))
#plt.ylim((0, 40))
plt.xlabel(r'$x$')
plt.ylabel(r'$y$')
y5 = np.minimum(y1, y2)
plt.fill_between(x, y3, y5, where=y3<y5, color='grey', alpha=0.5)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.show()

OUTPUT:

RESULT:
DATE:
EX.NO.8 (A) BACKTRACKING -N QUEEN PROBLEM

AIM:

To implement the N – Queen problem using python.

ALGORITHM:

Step1. Start in the leftmost column

Step2. If all queens are placed, return
true Step3. Try all rows in the current
column. Step4. Do following for every
tried row.
a. If the queen can be placed safely in this row then mark this [row, column] as part
of the solution and recursively check if placing, queen here leads to a solution.
b. If placing the queen in [row, column] leads to a solution then return true.
c. If placing queen doesn't lead to a solution then unmark this [row,
column] (Backtrack) and go to step (a) to try other rows.
d. If all rows have been tried and nothing worked,
e. return false to trigger backtracking.
PROGRAM:
global N
N=4
def printSolution(board):
for i in range(N):
for j in range(N):
print (board[i][j],end=' ')
print()

def isSafe(board, row, col):

# Check this row on left side

for i in range(col):
if board[row][i] == 1:
return False

# Check upper diagonal on left side

for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
if board[i][j] == 1:
return False
# Check lower diagonal on left side
for i, j in zip(range(row, N, 1), range(col, -1, -1)):
if board[i][j] == 1:
return False
return True
def solveNQUtil(board, col):
if col >= N:
return True
for i in range(N):
if isSafe(board, i, col):
# Place this queen in board[i][col]
board[i][col] = 1
 # recur to place rest of the queens
if solveNQUtil(board, col + 1) == True:
return True

# If placing queen in board[i][col

# doesn't lead to a solution, then
# queen from board[i][col]
board[i][col] = 0

# if the queen can not be placed in any row in

# this column col then return false
return False

def solveNQ():
board = [ [0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]
]

if solveNQUtil(board, 0) == False:
print ("Solution does not exist")
return False

printSolution(board)
return True

# driver program to test above function

solveNQ()
OUTPUT:

0010
1000
0001
0100

RESULT;
DATE:
EX.NO.8(B) BACKTRACKING -SUBSET SUM PROBLEMAIM:

To implement subset sum problem using python.

ALGORITHM:

Step1. Start with an empty set.

Step2. Include the next element from list to set.

Step3. If the numbers in the set sum up to given target_sum, It is a solution set

Step4. If the set doesnot sum upto the target_sum or if we have reached the end of
my_list, then backtrack the set until we find a solution set.

Step5. If we get a feasible solution, go to step 2

Step6.If we have traversed all the elements and if no backtracking is possible, then stop
without solution.

PROGRAM:
def sum_of_subset(s,k,rem):
x[k]=1
if s+my_list[k]==target_sum:
list1=[]
for i in range (0,k+1):
if x[i]==1:
list1.append(my_list[i])
print( list1 )
elif s+my_list[k]+my_list[k+1]<=target_sum :
sum_of_subset(s+my_list[k],k+1,rem-my_list[k])
if s+rem-my_list[k]>=target_sum and s+my_list[k+1]<=target_sum :
x[k]=0
sum_of_subset(s,k+1,rem-my_list[k])

my_list=[]
n=int(input("Enter number of elements"))
total=0
for i in range (0,n):
ele=int(input())
my_list.append(ele)
total=total+ele
my_list.sort()
target_sum=int(input("Enter required Sum"))
x=[0]*(n+1)
sum_of_subset(0,0,total)

OUTPUT:

Enter number of elements4

3
2
1
6
Enter required Sum6
[1, 2, 3]
[6]

RESULT:
DATE:
EX.NO:9.A) BRANCH AND BOUND-ASSIGNMENT PROBLEM

AIM:
To implement the assignment problem using python.

ALGORITHM:

Step1. For each row of the matrix, find the smallest element and subtract it from every
elementin its row.
Step2. Repeat the step 1 for all columns.
Step3. Cover all zeros in the matrix using the minimum number of horizontal and vertical
lines.
Step4. Test for Optimality: If the minimum number of covering lines is N, an
optimal assignment is possible. Else if lines are lesser than N, an optimal
assignmentis not found and must proceed to step 5.
Step5. Determine the smallest entry not covered by any line. Subtract this entry
fromeach uncovered row, and then add it to each covered column. Return
to step 3
PROGRAM:

# Python program for the above

approachimport dlib
# Function to find out the best
# assignment of people to jobs so that
# total cost of the assignment is
minimizeddef minCost(arr):
# Call the max_cost_assignment()
function# and store the assignment
assignment =
dlib.max_cost_assignment(arr)# Print the
optimal cost
print(dlib.assignment_cost(arr,
assignment))
# Driver Code
# Given 2D array
arr = dlib.matrix([[3, 5], [10,
1]])# Function Call
minCost(arr)

OUTPUT:
4

RESULT:
DATE:
EX.NO:9.B) BRANCH AND BOUND-TRAVELLING SALESMAN PROBLEM

AIM: To implement a program of travelling salesman problem in python

ALGORITHM:

Step1. Consider city 1 as the starting and ending

pointStep2. Generate all (n-1) permutaties of

cities

Step3. Calculate the cost of every permutation and keep track of the minimum cost

permutationStep4. Return the permutation with minimum cost and path.

PROGRAM:

import math

maxsize = float('inf')

def copyToFinal(curr_path):

final_path[:N + 1] = curr_path[:]

final_path[N] = curr_path[0]

def firstMin(adj, i):

min = maxsize

for k in range(N):

if adj[i][k] < min and i != k:

min = adj[i][k]

return min

def secondMin(adj, i):

first, second = maxsize, maxsize

for j in range(N):

if i == j:

continue

if adj[i][j] <= first:

second = first

first = adj[i][j]

elif(adj[i][j] <= second and

adj[i][j] != first):

second = adj[i][j]

return second

def TSPRec(adj, curr_bound, curr_weight,

level, curr_path, visited):

global final_res
# base case is when we have reached level N

# which means we have covered all the nodes once

if level == N:

# check if there is an edge from

# last vertex in path back to the first vertex

if adj[curr_path[level - 1]][curr_path[0]] != 0:

# curr_res has the total weight

# of the solution we got

curr_res = curr_weight + adj[curr_path[level - 1]]\

[curr_path[0]]

if curr_res < final_res:

copyToFinal(curr_path)

final_res = curr_res

return

# for any other level iterate for all vertices

# to build the search space tree recursively

for i in range(N):

# Consider next vertex if it is not same

# (diagonal entry in adjacency matrix and

# not visited already)

if (adj[curr_path[level-1]][i] != 0 and

visited[i] == False):

temp = curr_bound

curr_weight += adj[curr_path[level - 1]][i]

 # different computation of curr_bound

# for level 2 from the other levels

if level == 1:

curr_bound -= ((firstMin(adj, curr_path[level - 1])

firstMin(adj, i)) / 2)

else:

curr_bound -= ((secondMin(adj, curr_path[level - 1]) + firstMin(adj, i)) / 2)

# curr_bound + curr_weight is the actual lower

bound

# for the node that we have arrived on.

# If current lower bound < final_res,

# we need to explore the node further

if curr_bound + curr_weight < final_res:

curr_path[level] = i

visited[i] = True

# call TSPRec for the next level

TSPRec(adj, curr_bound, curr_weight,

level + 1, curr_path, visited)

# Else we have to prune the node by resetting

# all changes to curr_weight and curr_bound

curr_weight -= adj[curr_path[level - 1]][i]

curr_bound = temp

# Also reset the visited array

visited = [False] * len(visited)

for j in range(level):

if curr_path[j] != -1:
 visited[curr_path[j]] = True

# This function sets up final_path

def TSP(adj):

curr_bound = 0

curr_path = [-1] * (N + 1)

visited = [False] * N

# Compute initial bound

for i in range(N):

curr_bound += (firstMin(adj, i) +

secondMin(adj, i))

# Rounding off the lower bound to an integer

curr_bound = math.ceil(curr_bound / 2)

# We start at vertex 1 so the first vertex

# in curr_path[] is 0

visited[0] = True

curr_path[0] = 0

# Call to TSPRec for curr_weight

# equal to 0 and level 1

TSPRec(adj, curr_bound, 0, 1, curr_path, visited)

# Driver code

# Adjacency matrix for the given graph

adj = [[0, 10, 15, 20],

[10, 0, 35, 25],

[15, 35, 0, 30],

[20, 25, 30, 0]]

N=4

# final_path[] stores the final solution

# i.e. the // path of the salesman.

final_path = [None] * (N + 1)

# visited[] keeps track of the already

# visited nodes in a particular path

visited = [False] * N

# Stores the final minimum weight

# of shortest tour.

final_res = maxsize

TSP(adj)

print("Minimum cost :", final_res)

print("Path Taken : ", end = ' ')

for i in range(N + 1):

print(final_path[i], end = ' ')

OUTPUT:

Minimum cost : 80

Path Taken : 0 1 3 2 0

RESULT: