3.Write a program to prefrom knapsack problem using gridy solution.

def knapsack(w,wt,val,n):

if n-0 or w-0:

return 0

if(wt[n-1]>w):

return knapsack(w,wt,val,n-1)

else:

return max(val[n-1]+knapsack(w-wt[n-1],wt,val.n-1),knapsack(w,wt,val,n-

1))

profit [60.100.120] weight-[10.20.30]

w=50

n=len(profit)

cost-knapsack(w.weight.profit.n)

print("the maximun profit by using knapsack problem i:".cost)

1.Selection sort(using user input)

def selection_sort(arr):

n-len(arr)

for i in range(n):

min-i

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

if arr[j]<arr[min]:

min-j

arr[i],arr[min]= arr[min],arr[i]

n=int(input("enter number of elements:"))

arr=[]

print("enter".n."elements")

for i in range(n):

num=int(input(f'enter (i+1}:"))

arr.append(num)

print("original array is=".arr)

selection_sort(arr)

print("sorted array is=".arr)

4.write a program to implement DFS graph.

#comment:DFS function

def dfs(graph,start, visited=None):

if visited is None:

visited=set()mm

print(start,end=")

visited.add(start)

for neighbor in graph[start]:

if neighbor not in visited:

dfs(graph,neighbor, visited)

#comment:graph as an adjacency list

graph={

'A': ['B','C'],

'B':['D','E'],

'C': ['F'],

'D':[],

'E': ['F'],

'F':

}

#comment:starting dfs from node 'A'

print("DFS traversal:")

dfs(graph,'A')

2. Write a program to perfrom travalling salesman problem.

from itertools import permutations

graph=[

[0,10,15,20],

[10,0,35,25],

[15,35,0,30],

[20,25,30,0]

cities=[1,2,3]

min_cost-float('inf)

best route=

for perm in permutations(cities):

route=[0]+list(perm)+[0]

cost-0

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

cost+=graph[route[i]][route[i+1]]

if cost min cost:

min cost-cost

best route-route

print("best route:",best_route)

print("minimum cost:".min_cost)

def create graph(n,e)

adj=[[0]*n for in range (n)]

print("enter edges (u,v):")

for in range (e):

u,v=map(int,input().split())

adj [u] [v]=1

return adj

def print matrix(adj):

print("Adjacency matrix")

for row in adj:

print(" ".join(map(str,row)))

def degree (adj):

n=len(adj)

print("Indegree and out degree of each vertex:")

for i in range(n):

out_deg=sum(adj[i])

in_deg=sum(adj[j][i] for j in range(n))

print (f"vertex (1): In_degree-fin_deg),out degreen(out_deg)")

n-int ( input("enter number of vertices:"))

e-int (input("enter number of edges:"))

adj-create_graph (n,e)

print_matrix(adj)

degree (adj)

#include<stdio.h>

#define MAX 10

int main()

{

int n,e,u,v

int adj[MAX][MAX]; 

printf("enter number of vertices:");

scanf("%d",&n);

for(int i=0;i<n;i++)

for(int j=0;j<n;j++)

adj[i][j]=0;

printf("enter number of edges:");

scanf("%d",&e);

printf("enter edges (u,v):\n");

{

for(int i=0;i<e;i++)

scanf("%d%d",&u,v);

adj[u][v]-1

adj[v][u]-13

}

printf("Adjacency matrix");

for(int i=0;i<n;i++)

{

for(int j=0;j<n;j++)

printf("%d",adj[i][j]);

printf("\n");

}

return 0;

}