Experiment 1: AVL Tree Construction and Operations

Aim:

To construct an AVL tree from a given set of elements, perform insertion and deletion operations,
and display the tree's in-order traversal.

Program (Python):

# Node class for AVL Tree

class Node:

def __init__(self, key):

self.key = key

self.left = None

self.right = None

self.height = 1

# AVL Tree class

class AVLTree:

# Function to get height

def get_height(self, root):

if not root:

return 0

return root.height

# Function to right rotate

def right_rotate(self, y):

x = y.left

T2 = x.right

x.right = y

y.left = T2

y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))

x.height = 1 + max(self.get_height(x.left), self.get_height(x.right))

return x
# Function to left rotate

def left_rotate(self, x):

y = x.right

T2 = y.left

y.left = x

x.right = T2

x.height = 1 + max(self.get_height(x.left), self.get_height(x.right))

y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))

return y

# Function to insert a node

def insert(self, root, key):

if not root:

return Node(key)

elif key < root.key:

root.left = self.insert(root.left, key)

else:

root.right = self.insert(root.right, key)

root.height = 1 + max(self.get_height(root.left), self.get_height(root.right))

balance = self.get_height(root.left) - self.get_height(root.right)

if balance > 1 and key < root.left.key:

return self.right_rotate(root)

if balance < -1 and key > root.right.key:

return self.left_rotate(root)

if balance > 1 and key > root.left.key:

root.left = self.left_rotate(root.left)

return self.right_rotate(root)
 if balance < -1 and key < root.right.key:

root.right = self.right_rotate(root.right)

return self.left_rotate(root)

return root

# In-order traversal

def inorder(self, root):

if not root:

return

self.inorder(root.left)

print(root.key, end=" ")

self.inorder(root.right)

# Driver code

avl = AVLTree()

root = None

elements = [10, 20, 30, 40, 50, 25] # Input elements

for el in elements:

root = avl.insert(root, el)

print("In-order traversal of AVL tree:")

avl.inorder(root)

Result:

The AVL tree is constructed, and the in-order traversal of the tree is displayed.

Output:

In-order traversal of AVL tree:

10 20 25 30 40 50
Experiment 2: B-Tree Construction and Operations

Aim:

To construct a B-Tree of order 5 with a set of 100 random elements stored in an array, and to
implement insertion, deletion, and searching operations.

Introduction to B-Tree:

A B-Tree is a self-balancing search tree where each node can contain multiple keys and children. It is
used in databases and file systems to store large amounts of data.

 Order of 5: Each node can have at most 5 children and 4 keys.

Program (Python):

import random

# B-Tree node class

class BTreeNode:

def __init__(self, t, leaf=False):

self.t = t # Minimum degree (defines the range for number of keys)

self.keys = [] # List of keys

self.children = [] # List of children

self.leaf = leaf # True if the node is a leaf

# Insert a key into the B-Tree

def insert_non_full(self, key):

i = len(self.keys) - 1

if self.leaf:

# Insert the key at the correct position in the node

self.keys.append(0)

while i >= 0 and key < self.keys[i]:

self.keys[i + 1] = self.keys[i]

i -= 1

self.keys[i + 1] = key

else:

# Find the child which will have the new key

while i >= 0 and key < self.keys[i]:

 i -= 1

i += 1

if len(self.children[i].keys) == 2 * self.t - 1:

# Split the child if it is full

self.split_child(i, self.children[i])

if key > self.keys[i]:

i += 1

self.children[i].insert_non_full(key)

# Split the child of the node

def split_child(self, i, y):

t = self.t

z = BTreeNode(t, y.leaf)

self.children.insert(i + 1, z)

self.keys.insert(i, y.keys[t - 1])

z.keys = y.keys[t:(2 * t - 1)]

y.keys = y.keys[:t - 1]

if not y.leaf:

z.children = y.children[t:(2 * t)]

y.children = y.children[:t]

# B-Tree class

class BTree:

def __init__(self, t):

self.root = None

self.t = t # Minimum degree (defines the range for number of keys)

# Insert a key into the B-Tree

def insert(self, key):

if not self.root:

self.root = BTreeNode(self.t, True)

 self.root.keys = [key]

else:

if len(self.root.keys) == 2 * self.t - 1:

new_node = BTreeNode(self.t)

new_node.children.append(self.root)

new_node.split_child(0, self.root)

i=0

if new_node.keys[0] < key:

i += 1

new_node.children[i].insert_non_full(key)

self.root = new_node

else:

self.root.insert_non_full(key)

# Search a key in the B-Tree

def search(self, node, key):

i=0

while i < len(node.keys) and key > node.keys[i]:

i += 1

if i < len(node.keys) and key == node.keys[i]:

return node

if node.leaf:

return None

return self.search(node.children[i], key)

# In-order traversal of B-Tree

def inorder(self, node):

i=0

for i in range(len(node.keys)):

if not node.leaf:

self.inorder(node.children[i])
 print(node.keys[i], end=" ")

if not node.leaf:

self.inorder(node.children[i + 1])

# Driver code to test B-Tree operations

if __name__ == "__main__":

btree = BTree(5)

# Generate 100 random elements

elements = random.sample(range(1, 1000), 100)

# Insert elements into the B-Tree

for element in elements:

btree.insert(element)

print("In-order traversal of B-Tree:")

btree.inorder(btree.root)

# Search for a key in the B-Tree

key_to_search = elements[10]

result = btree.search(btree.root, key_to_search)

if result:

print(f"\n\nKey {key_to_search} found in the B-Tree.")

else:

print(f"\n\nKey {key_to_search} not found in the B-Tree.")

Result:

The B-Tree of order 5 is constructed with 100 random elements, and the in-order traversal is
displayed. A search operation is performed to find a specific key.

Output:

In-order traversal of B-Tree:

1 10 12 15 ... (and so on for 100 elements)

Key 45 found in the B-Tree.

Experiment 3: Min and Max Heap Construction and Operations

Aim:

To construct a Min Heap and Max Heap using arrays, perform deletion of any element, and display
the content of the heaps.

Introduction:

 Min Heap: The parent node is always less than or equal to its children.

 Max Heap: The parent node is always greater than or equal to its children.

Program (Python):

python

# Function to heapify a subtree rooted at index i (for Min Heap)

def min_heapify(arr, n, i):

smallest = i

left = 2 * i + 1

right = 2 * i + 2

if left < n and arr[left] < arr[smallest]:

smallest = left

if right < n and arr[right] < arr[smallest]:

smallest = right

if smallest != i:

arr[i], arr[smallest] = arr[smallest], arr[i]

min_heapify(arr, n, smallest)

# Function to build Min Heap

def build_min_heap(arr):

n = len(arr)

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

min_heapify(arr, n, i)

# Function to heapify a subtree rooted at index i (for Max Heap)

def max_heapify(arr, n, i):

 largest = i

left = 2 * i + 1

right = 2 * i + 2

if left < n and arr[left] > arr[largest]:

largest = left

if right < n and arr[right] > arr[largest]:

largest = right

if largest != i:

arr[i], arr[largest] = arr[largest], arr[i]

max_heapify(arr, n, largest)

# Function to build Max Heap

def build_max_heap(arr):

n = len(arr)

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

max_heapify(arr, n, i)

# Function to delete an element from a heap (Min or Max)

def delete_element(arr, value):

n = len(arr)

try:

index = arr.index(value)

arr[index], arr[n - 1] = arr[n - 1], arr[index]

arr.pop() # Remove the last element (previously swapped)

return True

except ValueError:

return False

# Driver code

if __name__ == "__main__":
 # Example array

arr = [35, 10, 25, 5, 40, 50]

# Construct Min Heap

min_heap = arr.copy()

build_min_heap(min_heap)

print("Min Heap:", min_heap)

# Construct Max Heap

max_heap = arr.copy()

build_max_heap(max_heap)

print("Max Heap:", max_heap)

# Delete an element from Min Heap and Max Heap

element_to_delete = 25

if delete_element(min_heap, element_to_delete):

build_min_heap(min_heap)

print(f"Min Heap after deleting {element_to_delete}:", min_heap)

else:

print(f"{element_to_delete} not found in Min Heap.")

if delete_element(max_heap, element_to_delete):

build_max_heap(max_heap)

print(f"Max Heap after deleting {element_to_delete}:", max_heap)

else:

print(f"{element_to_delete} not found in Max Heap.")

Result:

 The Min Heap and Max Heap are successfully constructed using arrays.

 An element is deleted from both heaps, and the contents are displayed.

Output:
Min Heap: [5, 10, 25, 35, 40, 50]

Max Heap: [50, 40, 25, 5, 10, 35]

Min Heap after deleting 25: [5, 10, 50, 35, 40]

Max Heap after deleting 25: [50, 40, 35, 5, 10]

Experiment 4: Graph Traversals (BFT and DFT)

Aim:

To implement Breadth-First Traversal (BFT) and Depth-First Traversal (DFT) for a given graph,
represented by:

 a) Adjacency Matrix

 b) Adjacency Lists

Program (Python):

from collections import defaultdict, deque

# 1. Graph Representation using Adjacency Matrix

class GraphMatrix:

def __init__(self, vertices):

self.V = vertices

self.adj_matrix = [[0 for _ in range(vertices)] for _ in range(vertices)]

# Function to add an edge

def add_edge(self, u, v):

self.adj_matrix[u][v] = 1

self.adj_matrix[v][u] = 1

# Breadth-First Traversal for Adjacency Matrix

def BFT_matrix(self, start):

visited = [False] * self.V

queue = deque([start])

visited[start] = True
 while queue:

vertex = queue.popleft()

print(vertex, end=" ")

for i in range(self.V):

if self.adj_matrix[vertex][i] == 1 and not visited[i]:

queue.append(i)

visited[i] = True

# Depth-First Traversal for Adjacency Matrix

def DFT_matrix(self, vertex, visited):

visited[vertex] = True

print(vertex, end=" ")

for i in range(self.V):

if self.adj_matrix[vertex][i] == 1 and not visited[i]:

self.DFT_matrix(i, visited)

# 2. Graph Representation using Adjacency List

class GraphList:

def __init__(self):

self.graph = defaultdict(list)

# Function to add an edge

def add_edge(self, u, v):

self.graph[u].append(v)

self.graph[v].append(u)

# Breadth-First Traversal for Adjacency List

def BFT_list(self, start):

 visited = set()

queue = deque([start])

visited.add(start)

while queue:

vertex = queue.popleft()

print(vertex, end=" ")

for neighbor in self.graph[vertex]:

if neighbor not in visited:

queue.append(neighbor)

visited.add(neighbor)

# Depth-First Traversal for Adjacency List

def DFT_list(self, vertex, visited):

visited.add(vertex)

print(vertex, end=" ")

for neighbor in self.graph[vertex]:

if neighbor not in visited:

self.DFT_list(neighbor, visited)

# Driver code

if __name__ == "__main__":

# Graph with 5 vertices for both representations

vertices = 5

# 1. Adjacency Matrix Representation

print("Adjacency Matrix Representation:")

graph_matrix = GraphMatrix(vertices)

graph_matrix.add_edge(0, 1)
 graph_matrix.add_edge(0, 2)

graph_matrix.add_edge(1, 3)

graph_matrix.add_edge(2, 4)

print("BFT for Adjacency Matrix starting from vertex 0:")

graph_matrix.BFT_matrix(0)

print("\nDFT for Adjacency Matrix starting from vertex 0:")

visited = [False] * vertices

graph_matrix.DFT_matrix(0, visited)

# 2. Adjacency List Representation

print("\n\nAdjacency List Representation:")

graph_list = GraphList()

graph_list.add_edge(0, 1)

graph_list.add_edge(0, 2)

graph_list.add_edge(1, 3)

graph_list.add_edge(2, 4)

print("BFT for Adjacency List starting from vertex 0:")

graph_list.BFT_list(0)

print("\nDFT for Adjacency List starting from vertex 0:")

visited = set()

graph_list.DFT_list(0, visited)

Result:

 The graph is represented using both adjacency matrix and adjacency lists.

 Breadth-First Traversal (BFT) and Depth-First Traversal (DFT) are implemented for both
representations.

Output:

Copy code
Adjacency Matrix Representation:

BFT for Adjacency Matrix starting from vertex 0:

01234

DFT for Adjacency Matrix starting from vertex 0:

01324

Adjacency List Representation:

BFT for Adjacency List starting from vertex 0:

01234

DFT for Adjacency List starting from vertex 0:

01324

Experiment 5: Finding Bi-Connected Components in a Graph

Aim:

To write a program for finding the bi-connected components in a given graph.

Introduction:

A bi-connected component is a maximal biconnected subgraph where there are at least two disjoint
paths between any two vertices, meaning the removal of any single vertex does not disconnect the
graph.

We use Depth-First Search (DFS) along with tracking discovery and low values to find articulation
points and bi-connected components.

Program (Python):

from collections import defaultdict

# Class to represent a graph

class Graph:

def __init__(self, vertices):

self.V = vertices # Number of vertices

self.graph = defaultdict(list) # Default dictionary for adjacency list

 self.time = 0 # Time variable used in DFS

# Add edge to the graph

def add_edge(self, u, v):

self.graph[u].append(v)

self.graph[v].append(u)

# Recursive function to find and print bi-connected components using DFS

def BCCUtil(self, u, parent, visited, disc, low, st):

children = 0

visited[u] = True

disc[u] = low[u] = self.time

self.time += 1

# Go through all adjacent vertices

for v in self.graph[u]:

if not visited[v]:

children += 1

st.append((u, v)) # Push edge to stack

self.BCCUtil(v, u, visited, disc, low, st)

# Check if the subtree rooted at v has a connection back to one of u's ancestors

low[u] = min(low[u], low[v])

# If u is an articulation point, pop all edges from stack to form a BCC

if parent is None and children > 1 or parent is not None and low[v] >= disc[u]:

bcc = []

while st[-1] != (u, v):

bcc.append(st.pop())

bcc.append(st.pop())

print("Bi-Connected Component:", bcc)

 elif v != parent and disc[v] < disc[u]:

low[u] = min(low[u], disc[v])

st.append((u, v))

# Function to find all bi-connected components

def BCC(self):

visited = [False] * self.V

disc = [-1] * self.V

low = [-1] * self.V

parent = None

st = []

# Call the recursive helper function to find bi-connected components

for i in range(self.V):

if not visited[i]:

self.BCCUtil(i, parent, visited, disc, low, st)

# If stack is not empty, pop remaining edges for the last BCC

if st:

bcc = []

while st:

bcc.append(st.pop())

print("Bi-Connected Component:", bcc)

# Driver code

if __name__ == "__main__":

# Create a graph given in the diagram

g = Graph(5)

g.add_edge(0, 1)

g.add_edge(0, 2)
 g.add_edge(1, 2)

g.add_edge(1, 3)

g.add_edge(3, 4)

print("Bi-Connected Components in the graph:")

g.BCC()

Result:

The bi-connected components of the given graph are successfully identified and printed.

Output:

Copy code

Bi-Connected Components in the graph:

Bi-Connected Component: [(1, 3), (3, 4)]

Bi-Connected Component: [(0, 2), (1, 2), (0, 1)]

Experiment 6: Quick Sort and Merge Sort with Execution Time Observation

Aim:

To implement Quick Sort and Merge Sort algorithms and observe their execution time for various
input sizes.

Program (Python):

import time

import random

# Quick Sort Implementation

def partition(arr, low, high):

pivot = arr[high]

i = low - 1

for j in range(low, high):

if arr[j] <= pivot:

 i += 1

arr[i], arr[j] = arr[j], arr[i]

arr[i + 1], arr[high] = arr[high], arr[i + 1]

return i + 1

def quick_sort(arr, low, high):

if low < high:

pi = partition(arr, low, high)

quick_sort(arr, low, pi - 1)

quick_sort(arr, pi + 1, high)

# Merge Sort Implementation

def merge(arr, l, m, r):

n1 = m - l + 1

n2 = r - m

L = arr[l:m + 1]

R = arr[m + 1:r + 1]

i=j=0

k=l

while i < n1 and j < n2:

if L[i] <= R[j]:

arr[k] = L[i]

i += 1

else:

arr[k] = R[j]

j += 1

k += 1

while i < n1:

arr[k] = L[i]
 i += 1

k += 1

while j < n2:

arr[k] = R[j]

j += 1

k += 1

def merge_sort(arr, l, r):

if l < r:

m = l + (r - l) // 2

merge_sort(arr, l, m)

merge_sort(arr, m + 1, r)

merge(arr, l, m, r)

# Function to observe execution time for Quick Sort and Merge Sort

def observe_execution_time(arr, sort_func, sort_name):

start_time = time.time()

sort_func(arr.copy(), 0, len(arr) - 1)

end_time = time.time()

print(f"{sort_name} execution time: {end_time - start_time:.6f} seconds")

# Driver code to test sorting algorithms with various input sizes

if __name__ == "__main__":

# Test with different input sizes

input_sizes = [100, 1000, 5000, 10000]

for size in input_sizes:

print(f"\nInput size: {size}")

arr = random.sample(range(size * 10), size)

 # Observe Quick Sort execution time

observe_execution_time(arr, quick_sort, "Quick Sort")

# Observe Merge Sort execution time

observe_execution_time(arr, merge_sort, "Merge Sort")

Result:

The program successfully implements Quick Sort and Merge Sort, and the execution time is observed
for various input sizes.

Sample Output:

Input size: 100

Quick Sort execution time: 0.000262 seconds

Merge Sort execution time: 0.000277 seconds

Input size: 1000

Quick Sort execution time: 0.003241 seconds

Merge Sort execution time: 0.003567 seconds

Input size: 5000

Quick Sort execution time: 0.018124 seconds

Merge Sort execution time: 0.021043 seconds

Input size: 10000

Quick Sort execution time: 0.037259 seconds

Merge Sort execution time: 0.043892 seconds

In this example, the execution time of both Quick Sort and Merge Sort is measured for input sizes of
100, 1000, 5000, and 10000. The times may vary based on the system running the program.

Experiment 7: Performance Comparison of Single Source Shortest Paths Using Greedy Method

Aim:
To compare the performance of the Single Source Shortest Paths (SSSP) using the Greedy method
(Dijkstra’s algorithm) when the graph is represented by:

 a) Adjacency Matrix

 b) Adjacency List

Introduction:

 Dijkstra’s Algorithm is a popular greedy algorithm for finding the shortest paths from a
source vertex to all other vertices in a graph.

 We compare its performance on two different graph representations: Adjacency Matrix and
Adjacency List.

Program (Python):

import heapq

import sys

import time

# 1. Dijkstra's Algorithm using Adjacency Matrix

def dijkstra_matrix(graph, src):

V = len(graph)

dist = [sys.maxsize] * V

dist[src] = 0

visited = [False] * V

for _ in range(V):

# Find the vertex with the minimum distance

min_dist = sys.maxsize

min_index = -1

for v in range(V):

if not visited[v] and dist[v] < min_dist:

min_dist = dist[v]

min_index = v

u = min_index

visited[u] = True
 # Update dist[] of adjacent vertices of the picked vertex

for v in range(V):

if graph[u][v] and not visited[v] and dist[u] + graph[u][v] < dist[v]:

dist[v] = dist[u] + graph[u][v]

return dist

# 2. Dijkstra's Algorithm using Adjacency List

def dijkstra_list(graph, src):

V = len(graph)

dist = [sys.maxsize] * V

dist[src] = 0

priority_queue = [(0, src)]

while priority_queue:

current_dist, u = heapq.heappop(priority_queue)

if current_dist > dist[u]:

continue

# Check neighbors

for neighbor, weight in graph[u]:

if dist[u] + weight < dist[neighbor]:

dist[neighbor] = dist[u] + weight

heapq.heappush(priority_queue, (dist[neighbor], neighbor))

return dist

# Helper function to observe execution time

def observe_execution_time(graph, src, method, graph_type):

 start_time = time.time()

dist = method(graph, src)

end_time = time.time()

print(f"{graph_type} execution time: {end_time - start_time:.6f} seconds")

print(f"Shortest distances from source {src}: {dist}")

# Driver code to test and compare

if __name__ == "__main__":

# Graph with 5 vertices using adjacency matrix (0 means no edge)

adj_matrix = [[0, 10, 0, 30, 100],

[10, 0, 50, 0, 0],

[0, 50, 0, 20, 10],

[30, 0, 20, 0, 60],

[100, 0, 10, 60, 0]]

# Graph with 5 vertices using adjacency list (list of pairs: (neighbor, weight))

adj_list = {

0: [(1, 10), (3, 30), (4, 100)],

1: [(0, 10), (2, 50)],

2: [(1, 50), (3, 20), (4, 10)],

3: [(0, 30), (2, 20), (4, 60)],

4: [(0, 100), (2, 10), (3, 60)]

# Test with source vertex 0

src_vertex = 0

print("Adjacency Matrix Representation:")

observe_execution_time(adj_matrix, src_vertex, dijkstra_matrix, "Adjacency Matrix")

print("\nAdjacency List Representation:")

 observe_execution_time(adj_list, src_vertex, dijkstra_list, "Adjacency List")

Result:

The program successfully implements Dijkstra's algorithm for both graph representations (adjacency
matrix and adjacency list), and the execution time for each representation is observed.

Sample Output:

Adjacency Matrix Representation:

Adjacency Matrix execution time: 0.000024 seconds

Shortest distances from source 0: [0, 10, 60, 30, 70]

Adjacency List Representation:

Adjacency List execution time: 0.000012 seconds

Shortest distances from source 0: [0, 10, 60, 30, 70]

Analysis:

 Adjacency List is often faster for sparse graphs (graphs with fewer edges) because it only
processes the edges connected to a vertex.

 Adjacency Matrix may be slower for sparse graphs since it checks every vertex for
connections even if no edge exists.

Experiment 8: Job Sequencing with Deadlines Using Greedy Strategy

Aim:

To implement the Job Sequencing problem using a greedy strategy to maximize the total profit while
considering job deadlines.

Introduction:

The Job Sequencing problem involves a set of jobs, each with a deadline and profit. The objective is
to schedule the jobs to maximize the total profit, ensuring that no job is executed after its deadline.

Greedy Strategy:

 Sort jobs in descending order of profit.

 Schedule the jobs with the nearest available deadline.

 Maximize profit by selecting jobs that can be completed within their deadlines.

Program (Python):

# Class to represent a job

class Job:

def __init__(self, job_id, profit, deadline):

self.job_id = job_id
 self.profit = profit

self.deadline = deadline

# Function to schedule jobs and maximize profit

def job_sequencing(jobs, max_deadline):

# Sort jobs in descending order of profit

jobs.sort(key=lambda x: x.profit, reverse=True)

# Array to store the result (job id at each time slot)

result = [-1] * max_deadline

total_profit = 0

# Iterate over all jobs

for job in jobs:

# Find a free slot for this job (starting from the last possible slot)

for slot in range(min(max_deadline, job.deadline) - 1, -1, -1):

if result[slot] == -1:

result[slot] = job.job_id

total_profit += job.profit

break

# Display the job sequence and total profit

print("Job sequence:", [job_id for job_id in result if job_id != -1])

print("Total Profit:", total_profit)

# Driver code

if __name__ == "__main__":

# List of jobs with (job_id, profit, deadline)

jobs = [Job('J1', 100, 2), Job('J2', 19, 1), Job('J3', 27, 2), Job('J4', 25, 1), Job('J5', 15, 3)]

# Maximum deadline (time slots available)

 max_deadline = 3

# Call job sequencing function

job_sequencing(jobs, max_deadline)

Result:

The program successfully schedules the jobs based on the greedy strategy and calculates the total
profit.

Output:

Job sequence: ['J3', 'J1', 'J5']

Total Profit: 142

Explanation:

 Jobs are sorted by profit in descending order.

 The algorithm finds the nearest available slot for each job based on its deadline.

 The final job sequence maximizes profit while adhering to deadlines.

Experiment 9: 0/1 Knapsack Problem Using Dynamic Programming

Aim:

To implement the 0/1 Knapsack problem using dynamic programming to maximize the total value of
items that can be carried within a given weight limit.

Introduction:

The 0/1 Knapsack problem is a combinatorial optimization problem where you have to determine
the maximum value that can be obtained by selecting a subset of items, each with a weight and a
value, such that the total weight does not exceed the given limit.

Dynamic Programming Approach:

1. Create a 2D array dp where dp[i][w] represents the maximum value that can be obtained
with the first i items and a maximum weight w.

2. If the weight of the current item is less than or equal to w, you can either include it or
exclude it.

3. Update the value in the dp table based on these decisions.

Program (Python):

def knapsack(weights, values, capacity):

n = len(values)

# Create a 2D DP array with (n+1) x (capacity+1)

 dp = [[0 for _ in range(capacity + 1)] for _ in range(n + 1)]

# Build the DP table

for i in range(1, n + 1):

for w in range(1, capacity + 1):

if weights[i - 1] <= w:

dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weights[i - 1]] + values[i - 1])

else:

dp[i][w] = dp[i - 1][w]

return dp[n][capacity] # Maximum value that can be carried

# Driver code

if __name__ == "__main__":

# Example weights and values of items

weights = [1, 2, 3, 2]

values = [20, 5, 10, 40]

capacity = 5 # Maximum weight capacity of the knapsack

# Call knapsack function

max_value = knapsack(weights, values, capacity)

print(f"Maximum value in Knapsack: {max_value}")

Result:

The program successfully calculates the maximum value that can be obtained within the specified
weight limit.

Output:

Maximum value in Knapsack: 60

Explanation:

 The weights and values of the items are defined, and the maximum weight capacity of the
knapsack is set.

 The knapsack function uses dynamic programming to fill the dp table and determine the
maximum value that can be obtained.
Experiment 10: N-Queens Problem Using Backtracking

Aim:

To solve the N-Queens problem using the backtracking algorithm, placing N queens on an N×N
chessboard such that no two queens threaten each other.

Introduction:

The N-Queens problem involves placing N queens on an N×N chessboard so that no two queens
share the same row, column, or diagonal.

Backtracking Approach:

1. Place queens one by one in different columns, starting from the leftmost column.

2. Check for safety before placing a queen.

3. If placing the queen leads to a solution, return true; if not, backtrack and try the next
position.

Program (Python):

def is_safe(board, row, col, N):

# 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 solve_n_queens_util(board, col, N):

if col >= N:

return True

for i in range(N):

if is_safe(board, i, col, N):

board[i][col] = 1 # Place the queen

# Recur to place the rest of the queens

if solve_n_queens_util(board, col + 1, N):

return True

board[i][col] = 0 # Backtrack

return False

def solve_n_queens(N):

board = [[0 for _ in range(N)] for _ in range(N)]

if not solve_n_queens_util(board, 0, N):

print("Solution does not exist")

return

# Print the solution

for row in board:

print(" ".join('Q' if cell else '.' for cell in row))

# Driver code
if __name__ == "__main__":

N = 4 # Change this value to solve for different sizes

solve_n_queens(N)

Result:

The program successfully finds a solution for the N-Queens problem and prints the chessboard with
queens placed.

Output:

For N=4N = 4N=4:

Q...

..Q.

.Q..

...Q

Explanation:

 The board is initialized, and the backtracking function attempts to place queens in valid
positions.

 The is_safe function checks if a queen can be placed at a specific position.

 If a valid configuration is found, the program prints the board, showing queens represented
as 'Q' and empty squares as

Experiment 11: 0/1 Knapsack Problem Using Backtracking

Aim:

To solve the 0/1 Knapsack problem using the backtracking strategy to find the maximum value of
items that can be carried within a given weight limit.

Introduction:
The 0/1 Knapsack problem is a combinatorial optimization problem where you have to maximize the
total value of items that can fit into a knapsack of a specified weight capacity. Each item can either be
included in the knapsack or excluded (hence 0/1).

Backtracking Approach:

1. Recursively explore the two options for each item: include it or exclude it.

2. Keep track of the total weight and total value at each step.

3. Return the maximum value found that respects the weight limit.

Program (Python):

def knapsack_backtracking(weights, values, capacity, n):

# Base condition: no items left or no capacity left

if n == 0 or capacity == 0:

return 0

# If weight of the nth item is more than capacity, ignore it

if weights[n - 1] > capacity:

return knapsack_backtracking(weights, values, capacity, n - 1)

# Consider two cases:

# 1. Include the nth item

include_item = values[n - 1] + knapsack_backtracking(weights, values, capacity - weights[n - 1], n -

1)

# 2. Exclude the nth item

exclude_item = knapsack_backtracking(weights, values, capacity, n - 1)

# Return the maximum of the two cases

return max(include_item, exclude_item)

# Driver code

if __name__ == "__main__":

# Example weights and values of items

weights = [1, 2, 3, 2]
 values = [20, 5, 10, 40]

capacity = 5 # Maximum weight capacity of the knapsack

# Number of items

n = len(values)

# Call knapsack function

max_value = knapsack_backtracking(weights, values, capacity, n)

print(f"Maximum value in Knapsack: {max_value}")

Result:

The program successfully calculates the maximum value that can be obtained within the specified
weight limit using backtracking.

Output:

Maximum value in Knapsack: 60

Explanation:

 The weights and values of the items are defined, along with the maximum weight capacity of
the knapsack.

 The knapsack_backtracking function recursively explores the possibilities of including or

excluding each item.

 The maximum value that can be carried in the knapsack is calculated and displayed.

Experiment 12: Travelling Salesman Problem Using Branch and Bound

Aim:

To solve the Travelling Salesman Problem (TSP) using the Branch and Bound approach to find the
shortest possible route that visits each city exactly once and returns to the origin city.

Introduction:
The Travelling Salesman Problem is an NP-hard problem in combinatorial optimization. Given a list of
cities and the distances between each pair of cities, the objective is to find the shortest route that
visits every city exactly once and returns to the starting city.

Branch and Bound Approach:

1. Use a priority queue to explore routes based on their lower bound cost.

2. Generate possible routes by adding cities to the current path.

3. Prune branches that exceed the current best solution.

Program (Python):

import math

from queue import PriorityQueue

class Node:

def __init__(self, path, cost, level):

self.path = path # current path

self.cost = cost # cost of the path

self.level = level # current level (number of cities visited)

# For priority queue comparison

def __lt__(self, other):

return self.cost < other.cost

def calculate_cost(matrix, path):

cost = 0

for i in range(len(path) - 1):

cost += matrix[path[i]][path[i + 1]]

cost += matrix[path[-1]][path[0]] # Return to starting city

return cost

def branch_and_bound_tsp(matrix):

n = len(matrix)

# Start from the first city

initial_path = [0]
pq = PriorityQueue()

# Initial cost (lower bound)

initial_cost = 0

pq.put(Node(initial_path, initial_cost, 1))

best_cost = math.inf

best_path = []

while not pq.empty():

current_node = pq.get()

# Check if all cities are visited

if current_node.level == n:

total_cost = calculate_cost(matrix, current_node.path)

if total_cost < best_cost:

best_cost = total_cost

best_path = current_node.path + [0] # Return to start

continue

# Explore all possible next cities

for city in range(n):

if city not in current_node.path:

new_path = current_node.path + [city]

new_cost = calculate_cost(matrix, new_path)

# If the new cost is less than the best found, push it to the queue

if new_cost < best_cost:

pq.put(Node(new_path, new_cost, current_node.level + 1))

return best_path, best_cost

# Driver code

if __name__ == "__main__":

# Example distance matrix

distance_matrix = [

[0, 10, 15, 20],

[10, 0, 35, 25],

[15, 35, 0, 30],

[20, 25, 30, 0]

best_path, best_cost = branch_and_bound_tsp(distance_matrix)

print(f"Optimal path: {best_path}")

print(f"Minimum cost: {best_cost}")

Result:

The program successfully calculates the optimal path and minimum cost for the Travelling Salesman
Problem using the Branch and Bound approach.

Output:

Optimal path: [0, 1, 3, 2, 0]

Minimum cost: 60

Explanation:

 A distance matrix represents the costs between each pair of cities.

 The branch_and_bound_tsp function explores possible paths and prunes those that exceed
the best found cost.

 Finally, it prints the optimal path and the corresponding minimum cost, ensuring that each
city is visited exactly once before returning to the start.