6(A)-GREEDY TECHNIQUE

DIJKSTRA’S ALGORITHM

PROGRAM:

import heapq

# Function to implement Dijkstra's algorithm using a greedy approach

def dijkstra(graph, start):
# Number of nodes in the graph
num_nodes = len(graph)

# Initialize distances from start to all nodes as infinity

distances = {node: float('inf') for node in range(num_nodes)}
distances[start] = 0 # Distance to start node is 0

# Priority queue to keep track of the next node to visit

pq = [(0, start)] # (distance, node)

while pq:
# Get the node with the smallest distance
current_distance, current_node = heapq.heappop(pq)

# If the current distance is greater than the recorded distance, skip processing
if current_distance > distances[current_node]:
continue

# Explore each neighbor of the current node

for neighbor, weight in graph[current_node]:
 distance = current_distance + weight

# If a shorter path to the neighbor is found, update the distance and add to queue
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(pq, (distance, neighbor))

return distances

# Function to take user input and run the algorithm

def main():
# Get number of nodes and edges from the user
num_nodes = int(input("Enter number of nodes: "))
num_edges = int(input("Enter number of edges: "))

# Initialize the graph as an adjacency list

graph = {i: [] for i in range(num_nodes)}

# Get the edges from the user (format: node1 node2 weight)
for _ in range(num_edges):
u, v, w = map(int, input("Enter edge (u, v, weight): ").split())
graph[u].append((v, w))
graph[v].append((u, w)) # Assuming an undirected graph

# Get the source node for Dijkstra's algorithm

start_node = int(input("Enter the start node: "))

# Run Dijkstra's algorithm

distances = dijkstra(graph, start_node)

# Output the shortest distances

 print("\nShortest distances from node", start_node)
for node, distance in distances.items():
print(f"Node {node}: {distance}")

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

Enter number of nodes: 5

Enter number of edges: 6
Enter edge (u, v, weight): 0 1 10
Enter edge (u, v, weight): 0 2 5
Enter edge (u, v, weight): 1 2 2
Enter edge (u, v, weight): 1 3 1
Enter edge (u, v, weight): 2 3 9
Enter edge (u, v, weight): 3 4 4
Enter the start node: 0
Shortest distances from node 0
Node 0: 0
Node 1: 7
Node 2: 5
Node 3: 8
Node 4: 12
 6(B)-GREEDY TECHNIQUE
HUFFMAN TREES AND CODES

PROGRAM:

import heapq

# Helper class for Huffman Tree Node

class Node:
def __init__(self, char, freq):
self.char = char
self.freq = freq
self.left = None
self.right = None

# For heapq to compare nodes based on frequency

def __lt__(self, other):
return self.freq < other.freq

# Function to build the Huffman Tree

def build_huffman_tree(freq_table):
# Create a priority queue (min-heap)
heap = [Node(char, freq) for char, freq in freq_table.items()]
heapq.heapify(heap)

# Build the Huffman Tree

while len(heap) > 1:
# Pop the two nodes with the lowest frequency
left = heapq.heappop(heap)
 right = heapq.heappop(heap)

# Create a new internal node with the sum of frequencies

merged_node = Node(None, left.freq + right.freq)
merged_node.left = left
merged_node.right = right

# Push the internal node back into the priority queue

heapq.heappush(heap, merged_node)

# The root of the tree is the only remaining node in the heap
return heap[0]

# Function to generate Huffman codes from the tree

def generate_huffman_codes(node, current_code, codes):
if node is None:
return

# If we reached a leaf node, assign the Huffman code

if node.char is not None:
codes[node.char] = current_code

# Recursively generate codes for left and right subtrees

generate_huffman_codes(node.left, current_code + '0', codes)
generate_huffman_codes(node.right, current_code + '1', codes)

# Function to encode the text using Huffman codes

def encode_text(text, huffman_codes):
return ''.join(huffman_codes[char] for char in text)

# Function to decode the encoded text using the Huffman tree

def decode_text(encoded_text, root):
decoded_text = []
current_node = root
for bit in encoded_text:
# Traverse the tree based on the bit (0 = left, 1 = right)
current_node = current_node.left if bit == '0' else current_node.right

# If we reach a leaf node, add the character to decoded text

if current_node.char is not None:
decoded_text.append(current_node.char)
current_node = root # Restart from root after decoding a character

return ''.join(decoded_text)

# Main function to handle user input and perform the operations

def main():
# Get the number of characters in the frequency table
num_chars = int(input("Enter the number of unique characters: "))

# Input the character and frequency pairs

freq_table = {}
print("Enter character and frequency pairs (e.g., A 5, B 9, C 12):")
for _ in range(num_chars):
char, freq = input().split()
freq_table[char] = int(freq)

# Build Huffman Tree using the frequency table

root = build_huffman_tree(freq_table)

# Generate Huffman codes from the tree

huffman_codes = {}
 generate_huffman_codes(root, '', huffman_codes)

# Display the generated Huffman codes

print("\nHuffman Codes:")
for char, code in huffman_codes.items():
print(f"Character: '{char}' | Code: {code}")

# Take the text input for encoding

text = input("\nEnter the text to encode: ")

# Encode the text using Huffman codes

encoded_text = encode_text(text, huffman_codes)
print("\nEncoded text:", encoded_text)

# Decode the encoded text

decoded_text = decode_text(encoded_text, root)
print("\nDecoded text:", decoded_text)

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

Enter the number of unique characters: 5

Enter character and frequency pairs (e.g., A 5, B 9, C 12):
A5
B9
C 12
D 13
E 16

Enter the text to encode: ABCD

Huffman Codes:
Character: 'A' | Code: 000
Character: 'B' | Code: 01
Character: 'C' | Code: 10
Character: 'D' | Code: 11
Character: 'E' | Code: 111

Encoded text: 0000101011

Decoded text: ABCD

 7-ITERATIVE IMPROVEMENT
SIMPLEX METHOD

PROGRAM:

import numpy as np

def simplex(c, A, b):

num_variables = len(c)
num_constraints = len(b)

tableau = np.hstack([A, np.eye(num_constraints), b.reshape(-1, 1)])

objective_row = np.hstack([c, np.zeros(num_constraints + 1)])
tableau = np.vstack([tableau, objective_row])

while True:
if np.all(tableau[-1, :-1] >= 0):
return tableau[:-1, -1], tableau[-1, -1]

pivot_col = np.argmin(tableau[-1, :-1])

ratios = tableau[:-1, -1] / tableau[:-1, pivot_col]

ratios[ratios <= 0] = np.inf
pivot_row = np.argmin(ratios)

pivot_value = tableau[pivot_row, pivot_col]

tableau[pivot_row] /= pivot_value

for i in range(len(tableau)):
 if i != pivot_row:
tableau[i] -= tableau[i, pivot_col] * tableau[pivot_row]

def main():
num_variables = int(input("Enter the number of variables: "))
num_constraints = int(input("Enter the number of constraints: "))

c = np.array(list(map(float, input(f"Enter the coefficients of the objective function (c):

").split())))

A = []
for _ in range(num_constraints):
A.append(list(map(float, input(f"Enter the coefficients for constraint {_ + 1}: ").split())))

b = np.array(list(map(float, input("Enter the right-hand side values (b): ").split())))

optimal_solution, optimal_value = simplex(c, np.array(A), b)

print("\nOptimal Solution (Variable Values):")

for i, value in enumerate(optimal_solution):
print(f"x{i + 1} = {value}")

print(f"\nOptimal Value of the Objective Function: {optimal_value}")

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

Enter the number of variables: 2

Enter the number of constraints: 2
Enter the coefficients of the objective function (c): 3 2
Enter the coefficients for constraint 1: 1 1
Enter the coefficients for constraint 2: 2 1
Enter the right-hand side values (b): 4 5
Optimal Solution (Variable Values):
x1 = 1.0
x2 = 3.0

Optimal Value of the Objective Function: 9.0

 8(A)-BACKTRACKING N-QUEEN PROBLEM

PROGRAM:

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

for i in range(row):
if board[i] == col or \
board[i] - i == col - row or \
board[i] + i == col + row:
return False
return True

def solve_nqueens(board, row, n):

if row == n:
print_solution(board, n)
return True

res = False
for col in range(n):
if is_safe(board, row, col, n):
board[row] = col
res = solve_nqueens(board, row + 1, n) or res
board[row] = -1 # Backtrack

return res

def print_solution(board, n):

 for i in range(n):
row = ['.'] * n
row[board[i]] = 'Q'
print(' '.join(row))
print()

def main():
n = int(input("Enter the number of queens (N): "))
board = [-1] * n
if not solve_nqueens(board, 0, n):
print("Solution does not exist")

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

Enter the number of queens (N): 4

.Q..
...Q
Q...
..Q.
 8(B)-BACKTRACKING-SUBSET SUM PROBLEM

PROGRAM:

def subset_sum(arr, target, current_sum=0, index=0, current_subset=[]):

if current_sum == target:
print("Subset found:", current_subset)
return True
if current_sum > target or index >= len(arr):
return False

# Include the current element in the subset

current_subset.append(arr[index])
if subset_sum(arr, target, current_sum + arr[index], index + 1, current_subset):
return True

# Backtrack and exclude the current element from the subset

current_subset.pop()
if subset_sum(arr, target, current_sum, index + 1, current_subset):
return True

return False

def main():
arr = list(map(int, input("Enter the array of numbers: ").split()))
target = int(input("Enter the target sum: "))
 if not subset_sum(arr, target):
print("No subset found with the given sum.")

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

Enter the array of numbers: 3 34 4 12 5 2

Enter the target sum: 9
Subset found: [4, 5]
9(A)-BRANCH AND BOUND-ASSIGNEMENT PROBLEM

PROGRAM:

import numpy as np
import heapq

class Node:
def __init__(self, level, cost_matrix, assigned, cost, bound):
self.level = level
self.cost_matrix = cost_matrix
self.assigned = assigned
self.cost = cost
self.bound = bound

def __lt__(self, other):

return self.bound < other.bound

def calculate_lower_bound(cost_matrix, assigned, n):

# Calculate the lower bound based on row and column reductions
# First reduce rows
row_reduced = np.copy(cost_matrix)
row_min = np.min(row_reduced, axis=1)
row_reduced -= row_min[:, np.newaxis]

# Then reduce columns

col_reduced = np.copy(row_reduced)
 col_min = np.min(col_reduced, axis=0)
col_reduced -= col_min

# The lower bound is the sum of the row and column reductions
row_reduction_sum = np.sum(row_min)
col_reduction_sum = np.sum(col_min)

return row_reduction_sum + col_reduction_sum

def branch_and_bound(cost_matrix, n):

# Initialize the best solution as a large number
best_cost = float('inf')
best_assignment = None

# Priority queue to explore the state space

queue = []

# Initial Node (level -1, no assignments, no cost, and initial bound)

assigned = [-1] * n
initial_bound = calculate_lower_bound(cost_matrix, assigned, n)
root = Node(-1, cost_matrix, assigned, 0, initial_bound)

heapq.heappush(queue, root)

while queue:
node = heapq.heappop(queue)

# If the lower bound is greater than the best solution found so far, prune the branch
if node.bound >= best_cost:
continue
 # If we have assigned all tasks (level == n-1), check if we have a better solution
if node.level == n - 1:
if node.cost < best_cost:
best_cost = node.cost
best_assignment = node.assigned.copy()
continue

# Generate the next level nodes (assign the next task to a worker)
level = node.level + 1
for j in range(n):
if node.assigned[j] == -1: # If worker j is not yet assigned
new_assigned = node.assigned.copy()
new_assigned[j] = level

# Create a new cost matrix by marking the current row as assigned

new_cost_matrix = np.copy(node.cost_matrix)
new_cost_matrix[level, :] = float('inf') # Exclude the current row

# Calculate the new bound

new_cost = node.cost + cost_matrix[level][j]
new_bound = calculate_lower_bound(new_cost_matrix, new_assigned, n)

# If the bound is promising, push it into the priority queue

if new_bound < best_cost:
heapq.heappush(queue, Node(level, new_cost_matrix, new_assigned, new_cost,
new_bound))

return best_cost, best_assignment

def main():
# Read the input for the Assignment Problem
n = int(input("Enter the number of workers/tasks (n): "))
print("Enter the cost matrix:")
cost_matrix = []
for _ in range(n):
OUTPUT:

Enter the number of workers/tasks (n): 4

Enter the cost matrix:
10 15 20 25
20 25 30 35
30 35 40 45
40 45 50 55
Optimal Assignment (Task -> Worker): [0, 1, 2, 3]
Minimum Cost: 80
 9(B)-BRANCH AND BOUND-TRAVELLING SALES MAN

PROGRAM:

import numpy as np
import heapq

class Node:
def __init__(self, level, cost, path, bound):
self.level = level # Current level (number of cities visited)
self.cost = cost # Total cost of the path so far
self.path = path # List of cities visited so far
self.bound = bound # Lower bound for this node

def __lt__(self, other):

return self.bound < other.bound # Priority queue sorted by bound

def calculate_lower_bound(cost_matrix, path, n):

"""
Calculate the lower bound for a node.
Uses matrix reduction method (similar to the MST bound).
"""
# Calculate the row reduction
row_reduced = np.copy(cost_matrix)
for i in range(n):
row_min = np.min(row_reduced[i][np.where(row_reduced[i] != float('inf'))]) # min in
the row
if row_min != float('inf'):
row_reduced[i] -= row_min
 # Calculate the column reduction
col_reduced = np.copy(row_reduced)
for j in range(n):
col_min = np.min(col_reduced[np.where(col_reduced[:, j] != float('inf')), j]) # min in
the column
if col_min != float('inf'):
col_reduced[:, j] -= col_min

# Add row and column reductions to calculate the lower bound

row_reduction_sum = np.sum(np.min(row_reduced, axis=1))
col_reduction_sum = np.sum(np.min(col_reduced, axis=0))

return row_reduction_sum + col_reduction_sum

def branch_and_bound_tsp(cost_matrix, n):

# Priority queue to explore the search space
min_heap = []

# Initial state (starting from city 0)

path = [0]
cost = 0
initial_bound = calculate_lower_bound(cost_matrix, path, n)

root = Node(level=0, cost=cost, path=path, bound=initial_bound)

heapq.heappush(min_heap, root)

best_cost = float('inf')
best_path = None

while min_heap:
 # Get the node with the smallest bound (best possible solution so far)
node = heapq.heappop(min_heap)

# If the bound is greater than the best cost, prune this branch
if node.bound >= best_cost:
continue

# If all cities are visited, check if this is the best solution

if node.level == n - 1:
last_city = node.path[-1]
# Complete the tour by returning to the starting city
total_cost = node.cost + cost_matrix[last_city][0]
if total_cost < best_cost:
best_cost = total_cost
best_path = node.path + [0] # Return to the start city
continue

# Generate the child nodes (add a new city to the path)

for city in range(n):
if city not in node.path:
new_path = node.path + [city]
new_cost = node.cost + cost_matrix[node.path[-1]][city]
new_bound = calculate_lower_bound(cost_matrix, new_path, n)

# If the new bound is promising, push it into the queue

if new_bound < best_cost:
heapq.heappush(min_heap, Node(level=node.level + 1, cost=new_cost,
path=new_path, bound=new_bound))

return best_cost, best_path

def main():
# Input the number of cities
n = int(input("Enter the number of cities: "))
print("Enter the distance matrix:")
cost_matrix = []
for i in range(n):
row = list(map(int, input().split()))
cost_matrix.append(row)

# Solve the TSP using Branch and Bound

min_cost, best_path = branch_and_bound_tsp(np.array(cost_matrix), n)

print(f"\nOptimal Path: {best_path}")

print(f"Minimum Cost: {min_cost}")

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

Enter the number of cities: 4

Enter the distance matrix:
0 10 15 20
10 0 35 25
15 35 0 30
20 25 30 0
Optimal Path: [0, 1, 3, 2, 0]
Minimum Cost: 80