217008 DATE- / /2023

PROGRAM NO. –1
WRITE A PROGRAM TO IMPLEMENT 0/1 KNAPSACK PROBLEM USING DYNAMIC
PROGRAMMING.
#include<stdio.h>
#include<conio.h>

void knapsack(int n, float weight[], float profit[], float capacity) {

float x[20], tp = 0;
int i, j, u;
u = capacity;

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

x[i] = 0.0;

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

if (weight[i] > u)
break;
else {
x[i] = 1.0;
tp = tp + profit[i];
u = u - weight[i];
}
}

if (i < n)
x[i] = u / weight[i];

tp = tp + (x[i] * profit[i]);

printf("\nThe result vector is:- ");

for (i = 0; i < n; i++)
printf("%f\t", x[i]);
 printf("\nMaximum profit is:- %f", tp);

int main() {
float weight[20], profit[20], capacity;
int num, i, j;
float ratio[20], temp;
clrscr();

printf("\nEnter the no. of objects:- ");

scanf("%d", &num);

printf("\nEnter the wts and profits of each object:- ");

for (i = 0; i < num; i++) {

printf("\nEnter the weight of object %d: ",i+1);
scanf("%f", &weight[i]);
printf("Enter the profit of object %d: ",i+1);
scanf("%f", &profit[i]);
}
printf("\nWeight\t\tProfit\n");
for(i=0;i<num;i++)
{
printf("\n%f\t%f",weight[i],profit[i]);
}

printf("\nEnter the capacity of knapsack:- ");

scanf("%f", &capacity);

for (i = 0; i < num; i++) {

ratio[i] = profit[i] / weight[i];
}

for (i = 0; i < num; i++) {

 for (j = i + 1; j < num; j++) {
if (ratio[i] < ratio[j]) {
temp = ratio[j];
ratio[j] = ratio[i];
ratio[i] = temp;

temp = weight[j];
weight[j] = weight[i];
weight[i] = temp;

temp = profit[j];
profit[j] = profit[i];
profit[i] = temp;
}
}
}

knapsack(num, weight, profit, capacity);

getch();
return(0);
}

SIGNATURE
217008 DATE- / /2023

PROGRAM NO. –2
WRITE A PROGRAM TO IMPLEMENT 0/1 KNAPSACK PROBLEM USING DYNAMIC
PROGRAMMING.
#include<iostream.h>
#include<conio.h>
int max(int a,int b)
{
return (a>b)? a:b;
}
int knapsack (int c,int w[],int p[],int n)
{
if (n==0||c== 0)
return 0 ;
if (w[n-1]>c)
return knapsack(c,w,p,n-1);
else
return max(p[n-1]+ knapsack(c-w[n-1],w,p,n-1),
knapsack(c,w,p,n-1));
}
int main()
{
int profit[]={60,100,120};
int weight[]={10,20,30};
int c=50;
int n = sizeof(profit)/sizeof(profit[0]);
clrscr();
cout<<"The optimal solution to 0/1 Knapsack problem is:
"<<knapsack(c,weight,profit,n);
getch();
return 0;
}

SIGNATURE
217008 DATE- / /2023

PROGRAM NO. –3
WRITE A PROGRAM TO FIND OPTIMAL SOLUTION TO MATRIX CHAIN
MULTIPLICATION USING DYNAMIC PROGRAMMING.
// C code to implement the
// matrix chain multiplication using recursion

#include <limits.h>
#include <stdio.h>

// Matrix Ai has dimension p[i-1] x p[i]

// for i = 1 . . . n
int MatrixChainOrder(int p[], int i, int j)
{
if (i == j)
return 0;
int k;
int min = INT_MAX;
int count;

// Place parenthesis at different places

// between first and last matrix,
// recursively calculate count of multiplications
// for each parenthesis placement
// and return the minimum count
for (k = i; k < j; k++)
{
count = MatrixChainOrder(p, i, k)
+ MatrixChainOrder(p, k + 1, j)
+ p[i - 1] * p[k] * p[j];

if (count < min)

min = count;
}
 // Return minimum count
return min;
}

// Driver code
int main()
{
int arr[] = { 1, 2, 3, 4, 3 };
int N = sizeof(arr) / sizeof(arr[0]);

// Function call
printf("Minimum number of multiplications is %d ",
MatrixChainOrder(arr, 1, N - 1));
getchar();
return 0;
}

SIGNATURE
217008 DATE- / /2023

PROGRAM NO. –4
WRITE A PROGRAM TO IMPLEMENT TRAVELLING SALESMAN PROBLEM USING
DYNAMIC PROGRAMMING.
#include<stdio.h>
#include<conio.h>

// there are four nodes in example graph (graph is 1-based)

const int n = 4;
// give appropriate maximum to avoid overflow
const int MAX = 1000000;
int min(int a,int b)
{
return (a>b)?b:a;
}

// dist[i][j] represents shortest distance to go from i to j

// this matrix can be calculated for any given graph using
int dist[n + 1][n + 1] = {
{ 0, 0, 0, 0, 0 }, { 0, 0, 10, 15, 20 },
{ 0, 10, 0, 25, 25 }, { 0, 15, 25, 0, 30 },
{ 0, 20, 25, 30, 0 },
};

// memoization for top down recursion

int memo[n + 1][1 << (n + 1)];

int fun(int i, int mask)

{
// base case
// if only ith bit and 1st bit is set in our mask,
// it implies we have visited all other nodes already
if (mask == ((1 << i) | 3))
return dist[1][i];
 // memoization
if (memo[i][mask] != 0)
return memo[i][mask];

int res = MAX; // result of this sub-problem

// we have to travel all nodes j in mask and end the

// path at ith node so for every node j in mask,
// recursively calculate cost of travelling all nodes in
// mask except i and then travel back from node j to
// node i taking the shortest path take the minimum of
// all possible j nodes
for (int j = 1; j <= n; j++)
if ((mask & (1 << j)) && j != i && j != 1)
res =min(res, fun(j, mask & (~(1 << i)))
+ dist[j][i]);
return memo[i][mask] = res;
}
int main()
{
int ans = MAX;
clrscr();
for (int i = 1; i <= n; i++)
// try to go from node 1 visiting all nodes in
// between to i then return from i taking the
// shortest route to 1
ans =min(ans, fun(i, (1 << (n + 1)) - 1)
+ dist[i][1]);
printf("The cost of most efficient tour = %d", ans);
getch();
return 0;
}

SIGNATURE
217008 DATE- / /2023

PROGRAM NO. –5
WRITE A PROGRAM TO FIND SHORTEST PATHS IN A GRAPH WITH POSITIVE
EDGE WEIGHTS USING DIJKASTRA’S ALGORITHM.
#include <stdio.h>
#define INFINITY 9999
#define MAX 10
#include<conio.h>

void Dijkstra(int Graph[MAX][MAX], int n, int start);

void Dijkstra(int Graph[MAX][MAX], int n, int start)

{
int cost[MAX][MAX], distance[MAX], pred[MAX];
int visited[MAX], count, mindistance, nextnode, i, j;

// Creating cost matrix

for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (Graph[i][j] == 0)
cost[i][j] = INFINITY;
else
cost[i][j] = Graph[i][j];

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

distance[i] = cost[start][i];
pred[i] = start;
visited[i] = 0;
}

distance[start] = 0;
visited[start] = 1;
count = 1;
 while (count < n - 1) {
mindistance = INFINITY;

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

if (distance[i] < mindistance && !visited[i]) {
mindistance = distance[i];
nextnode = i;
}

visited[nextnode] = 1;
for (i = 0; i < n; i++)
if (!visited[i])
if (mindistance + cost[nextnode][i] < distance[i]) {
distance[i] = mindistance + cost[nextnode][i];
pred[i] = nextnode;
}
count++;
}

// Printing the distance

for (i = 0; i < n; i++)
if (i != start) {
printf("\nDistance from source to %d: %d", i, distance[i]);
}
}
int main() {
int Graph[MAX][MAX], i, j, n, u;
n = 7;
clrscr();

Graph[0][0] = 0;
Graph[0][1] = 0;
Graph[0][2] = 1;
Graph[0][3] = 2;
Graph[0][4] = 0;
Graph[0][5] = 0;
Graph[0][6] = 0;

Graph[1][0] = 0;
Graph[1][1] = 0;
Graph[1][2] = 2;
Graph[1][3] = 0;
Graph[1][4] = 0;
Graph[1][5] = 3;
Graph[1][6] = 0;

Graph[2][0] = 1;
Graph[2][1] = 2;
Graph[2][2] = 0;
Graph[2][3] = 1;
Graph[2][4] = 3;
Graph[2][5] = 0;
Graph[2][6] = 0;

Graph[3][0] = 2;
Graph[3][1] = 0;
Graph[3][2] = 1;
Graph[3][3] = 0;
Graph[3][4] = 0;
Graph[3][5] = 0;
Graph[3][6] = 1;

Graph[4][0] = 0;
Graph[4][1] = 0;
Graph[4][2] = 3;
Graph[4][3] = 0;
Graph[4][4] = 0;
Graph[4][5] = 2;
Graph[4][6] = 0;
 Graph[5][0] = 0;
Graph[5][1] = 3;
Graph[5][2] = 0;
Graph[5][3] = 0;
Graph[5][4] = 2;
Graph[5][5] = 0;
Graph[5][6] = 1;

Graph[6][0] = 0;
Graph[6][1] = 0;
Graph[6][2] = 0;
Graph[6][3] = 1;
Graph[6][4] = 0;
Graph[6][5] = 1;
Graph[6][6] = 0;

u = 0;
Dijkstra(Graph, n, u);
getch();
return 0;
}

SIGNATURE
217008 DATE- / /2023

PROGRAM NO. –6
WRITE A PROGRAM TO FIND SHORTEST PATHS IN A GRAPH WITH ARBITRARY
EDGE WEIGHTS USING FLOYD’S ALGORITHM.
#include <stdio.h>
#include<conio.h>

// defining the number of vertices

#define nV 4

#define INF 999

void printMatrix(int matrix[][nV]);

// Implementing floyd warshall algorithm

void floydWarshall(int graph[][nV]) {
int matrix[nV][nV], i, j, k;

for (i = 0; i < nV; i++)

for (j = 0; j < nV; j++)
matrix[i][j] = graph[i][j];

// Adding vertices individually

for (k = 0; k < nV; k++) {
for (i = 0; i < nV; i++) {
for (j = 0; j < nV; j++) {
if (matrix[i][k] + matrix[k][j] < matrix[i][j])
matrix[i][j] = matrix[i][k] + matrix[k][j];
}
}
}
printMatrix(matrix);
}
void printMatrix(int matrix[][nV]) {
for (int i = 0; i < nV; i++) {
for (int j = 0; j < nV; j++) {
if (matrix[i][j] == INF)
printf("%4s", "INF");
else
printf("%4d", matrix[i][j]);
}
printf("\n");
}
}

int main() {
int graph[nV][nV] = {{0, 3, INF, 5},
{2, 0, INF, 4},
{INF, 1, 0, INF},
{INF, INF, 2, 0}};
clrscr();
floydWarshall(graph);
getch();
}

SIGNATURE
217008 DATE- / /2023

PROGRAM NO. –7
WRITE A PROGRAM TO FIND MINIMAL SPANNING TREE IN A WEIGHTED,
UNDIRECTED GRAPH USING PRIM’S ALGORITHM.
#include <stdio.h>
#include <limits.h>
#include<conio.h>
#define vertices 5 /*Define the number of vertices in the graph*/
/* create minimum_key() method for finding the vertex that has minimum
key-value and that is not added in MST yet */
int minimum_key(int k[], int mst[])
{
int minimum = INT_MAX, min,i;

/*iterate over all vertices to find the vertex with minimum key-value*/
for (i = 0; i < vertices; i++)
if (mst[i] == 0 && k[i] < minimum )
minimum = k[i], min = i;
return min;
}
/* create prim() method for constructing and printing the MST.
The g[vertices][vertices] is an adjacency matrix that defines the graph for
MST.*/
void prim(int g[vertices][vertices])
{
/* create array of size equal to total number of vertices for storing the
MST*/
int parent[vertices];
/* create k[vertices] array for selecting an edge having minimum
weight*/
int k[vertices];
int mst[vertices];
int i, count,edge,v; /*Here 'v' is the vertex*/
for (i = 0; i < vertices; i++)
 {
k[i] = INT_MAX;
mst[i] = 0;
}
k[0] = 0; /*It select as first vertex*/
parent[0] = -1; /* set first value of parent[] array to -1 to make it root of
MST*/
for (count = 0; count < vertices-1; count++)
{
/*select the vertex having minimum key and that is not added in the
MST yet from the set of vertices*/
edge = minimum_key(k, mst);
mst[edge] = 1;
for (v = 0; v < vertices; v++)
{
if (g[edge][v] && mst[v] == 0 && g[edge][v] < k[v])
{
parent[v] = edge, k[v] = g[edge][v];
}
}
}
/*Print the constructed Minimum spanning tree*/
printf("\n Edge \t Weight\n");
for (i = 1; i < vertices; i++)
printf(" %d <-> %d %d \n", parent[i], i, g[i][parent[i]]);

}
int main()
{
int g[vertices][vertices] = {{0, 0, 3, 0, 0},
{0, 0, 10, 4, 0},
{3, 10, 0, 2, 6},
{0, 4, 2, 0, 1},
{0, 0, 6, 1, 0},
};
 clrscr();
prim(g);
getch();
return 0;
}

SIGNATURE
217008 DATE- / /2023

PROGRAM NO. –8
WRITE A PROGRAM TO FIND MINIMAL SPANNING TREE IN A WEIGHTED,
UNDIRECTED GRAPH USING KRUSKAL’S ALGORITHM.

#include <stdio.h>
#include<conio.h>

#define MAX 30

typedef struct edge {

int u, v, w;
} edge;

typedef struct edge_list {

edge data[MAX];
int n;
} edge_list;

edge_list elist;

int Graph[MAX][MAX], n;
edge_list spanlist;

void kruskalAlgo();
int find(int belongs[], int vertexno);
void applyUnion(int belongs[], int c1, int c2);
void sort();
void print();

// Applying Krushkal Algo

void kruskalAlgo() {
int belongs[MAX], i, j, cno1, cno2;
elist.n = 0;
 for (i = 1; i < n; i++)
for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
elist.data[elist.n].v = j;
elist.data[elist.n].w = Graph[i][j];
elist.n++;
}
}

sort();

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

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}

int find(int belongs[], int vertexno) {

return (belongs[vertexno]);
}

void applyUnion(int belongs[], int c1, int c2) {

 int i;

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

if (belongs[i] == c2)
belongs[i] = c1;
}

// Sorting algo
void sort() {
int i, j;
edge temp;

for (i = 1; i < elist.n; i++)

for (j = 0; j < elist.n - 1; j++)
if (elist.data[j].w > elist.data[j + 1].w) {
temp = elist.data[j];
elist.data[j] = elist.data[j + 1];
elist.data[j + 1] = temp;
}
}

// Printing the result

void print() {
int i, cost = 0;

for (i = 0; i < spanlist.n; i++) {

printf("\n%d - %d : %d", spanlist.data[i].u, spanlist.data[i].v,
spanlist.data[i].w);
cost = cost + spanlist.data[i].w;
}

printf("\nSpanning tree cost: %d", cost);

}
int main()
{
int i, j, total_cost;

n = 6;
clrscr();

Graph[0][0] = 0;
Graph[0][1] = 4;
Graph[0][2] = 4;
Graph[0][3] = 0;
Graph[0][4] = 0;
Graph[0][5] = 0;
Graph[0][6] = 0;

Graph[1][0] = 4;
Graph[1][1] = 0;
Graph[1][2] = 2;
Graph[1][3] = 0;
Graph[1][4] = 0;
Graph[1][5] = 0;
Graph[1][6] = 0;

Graph[2][0] = 4;
Graph[2][1] = 2;
Graph[2][2] = 0;
Graph[2][3] = 3;
Graph[2][4] = 4;
Graph[2][5] = 0;
Graph[2][6] = 0;

Graph[3][0] = 0;
Graph[3][1] = 0;
Graph[3][2] = 3;
Graph[3][3] = 0;
 Graph[3][4] = 3;
Graph[3][5] = 0;
Graph[3][6] = 0;

Graph[4][0] = 0;
Graph[4][1] = 0;
Graph[4][2] = 4;
Graph[4][3] = 3;
Graph[4][4] = 0;
Graph[4][5] = 0;
Graph[4][6] = 0;

Graph[5][0] = 0;
Graph[5][1] = 0;
Graph[5][2] = 2;
Graph[5][3] = 0;
Graph[5][4] = 3;
Graph[5][5] = 0;
Graph[5][6] = 0;

kruskalAlgo();
print();
getch();
}

SIGNATURE