EXPERIMENT-12

AIM: Write a C program for knapsack problem using greedy approach.

SOURCE CODE:

# include<stdio.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];

Name: MANAN AGRAWAL

Roll No. : 2100910100102
tp= tp + (x[i]*profit[i]);

printf("\n The result vector is:- ");

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

printf("%f\t",x[i]);

printf("\n Maximum profit is:- %f", tp);

void main(){

float weight[20], profit[20], capacity;

int n, i ,j;

float ratio[20], temp;

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

scanf ("%d", &n);

printf ("Enter the weights and profits of each object:- ");

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

scanf("%f %f", &weight[i], &profit[i]);

printf (" enter the capacity of knapsack:- ");

scanf ("%f", &capacity);

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

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

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

for(j=i+1;j< n; j++) {

if(ratio[i]<ratio[j]) {

temp= ratio[j];

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 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(n, weight, profit, capacity);

OUTPUT:

Time Complexity:

● Best case: O(2N)

● Average Case: O(2N)
● Worst case: O(2N)

Space Complexity:
● O(N)
EXPERIMENT-13
Name: MANAN AGRAWAL
Roll No. : 2100910100102
AIM: Write a C program for Travelling salesman problem .

SOURCE CODE:

#include <stdio.h>

int matrix[25][25], visited_cities[10], limit, cost = 0;

int tsp(int c){

int count, nearest_city = 999;

int minimum = 999, temp;

for(count = 0; count < limit; count++) {

if((matrix[c][count] != 0) && (visited_cities[count] == 0)) {

if(matrix[c][count] < minimum) {

minimum = matrix[count][0] + matrix[c][count];

temp = matrix[c][count];

nearest_city = count;

} }

if(minimum != 999) {

cost = cost + temp;

return nearest_city;

void minimum_cost(int city){

int nearest_city;

visited_cities[city] = 1;

printf("%d ", city + 1);

nearest_city = tsp(city);

Name: MANAN AGRAWAL

Roll No. : 2100910100102
if(nearest_city == 999) {

nearest_city = 0;

printf("%d", nearest_city + 1);

cost = cost + matrix[city][nearest_city];

return;

minimum_cost(nearest_city);

int main(){

int i, j;

printf("Enter Total Number of Cities:\t");

scanf("%d", &limit);

printf("\nEnter Cost Matrix\n");

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

printf("\nEnter %d Elements in Row[%d]\n", limit, i + 1);

for(j = 0; j < limit; j++) {

scanf("%d", &matrix[i][j]);

visited_cities[i] = 0;

printf("\nEntered Cost Matrix\n");

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

printf("\n");

for(j = 0; j < limit; j++) {

Name: MANAN AGRAWAL

Roll No. : 2100910100102
printf("%d ", matrix[i][j]);

} }

printf("\n\nPath:\t");

minimum_cost(0);

printf("\n\nMinimum Cost: \t");

printf("%d\n", cost);

return 0; }

OUTPUT:

Time Complexity:

 O(N2*log2N)

Space Complexity:

● O(N)

EXPERIMENT-14

Name: MANAN AGRAWAL

Roll No. : 2100910100102
AIM: Find Minimum Spanning Tree using Kruskal’s Algorithm in C.

SOURCE CODE:

#include <stdio.h>

#include <stdlib.h>

int comparator(const void* p1, const void* p2) {

const int(*x)[3] = p1;

const int(*y)[3] = p2;

return (*x)[2] - (*y)[2];

void makeSet(int parent[], int rank[], int n) {

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

parent[i] = i;

rank[i] = 0;

} }

int findParent(int parent[], int component) {

if (parent[component] == component)

return component;

return parent[component]

= findParent(parent, parent[component]);

void unionSet(int u, int v, int parent[], int rank[], int n) {

u = findParent(parent, u);

v = findParent(parent, v);

if (rank[u] < rank[v]) {

parent[u] = v;

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 }

else if (rank[u] > rank[v]) {

parent[v] = u;

else {

parent[v] = u;

rank[u]++;

void kruskalAlgo(int n, int edge[n][3]) {

qsort(edge, n, sizeof(edge[0]), comparator);

int parent[n];

int rank[n];

makeSet(parent, rank, n);

int minCost = 0;

printf( "Following are the edges in the constructed MST\n");

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

int v1 = findParent(parent, edge[i][0]);

int v2 = findParent(parent, edge[i][1]);

int wt = edge[i][2];

if (v1 != v2) {

unionSet(v1, v2, parent, rank, n);

minCost += wt;

printf("%d -- %d == %d\n", edge[i][0], edge[i][1], wt);

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 }

printf("Minimum Cost Spanning Tree: %d\n", minCost);

int main() {

int edge[5][3] = { { 0, 1, 10 }, { 0, 2, 6 }, { 0, 3, 5 }, { 1, 3, 15 }, { 2, 3, 4 } };

kruskalAlgo(5, edge);

return 0;

OUTPUT:

Time Complexity:

● O(E * logE) or O(E * logV)

Space Complexity:

● O(V+E)

EXPERIMENT-15

Name: MANAN AGRAWAL

Roll No. : 2100910100102
AIM: Implement N Queen Problem using Backtracking in C.

SOURCE CODE:

#define N 4

#include <stdbool.h>

#include <stdio.h>

void printSolution(int board[N][N])

for (int i = 0; i < N; i++) {

for (int j = 0; j < N; j++) {

if(board[i][j])

printf("Q ");

else

printf(". ");

printf("\n");

bool isSafe(int board[N][N], int row, int col)

int i, j;

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

if (board[row][i])

return false;

for (i = row, j = col; i >= 0 && j >= 0; i--, j--)

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 if (board[i][j])

return false;

for (i = row, j = col; j >= 0 && i < N; i++, j--)

if (board[i][j])

return false;

return true;

bool solveNQUtil(int board[N][N], int col){

if (col >= N)

return true;

for (int i = 0; i < N; i++) {

if (isSafe(board, i, col)) {

board[i][col] = 1;

if (solveNQUtil(board, col + 1))

return true;

board[i][col] = 0;

return false;

bool solveNQ(){

int board[N][N] = { { 0, 0, 0, 0 },{ 0, 0, 0, 0 },{ 0, 0, 0, 0 },{ 0, 0, 0, 0 } };

if (solveNQUtil(board, 0) == false) {

printf("Solution does not exist");

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 return false;

printSolution(board);

return true;

int main() {

solveNQ();

return 0;

OUTPUT:

Time Complexity:

● O(N!)

Space Complexity:
● O(N^2)

EXPERIMENT-16

Name: MANAN AGRAWAL

Roll No. : 2100910100102
AIM: Find Minimum Cost Spanning Tree of a given undirected graph using Prim’s
algorithm in C.

SOURCE CODE:

#include <limits.h>

#include <stdbool.h>

#include <stdio.h>

#define V 5

int minKey(int key[], bool mstSet[]){

int min = INT_MAX, min_index;

for (int v = 0; v < V; v++)

if (mstSet[v] == false && key[v] < min)

min = key[v], min_index = v;

return min_index;

int printMST(int parent[], int graph[V][V]){

printf("Edge \tWeight\n");

for (int i = 1; i < V; i++)

printf("%d - %d \t%d \n", parent[i], i,

graph[i][parent[i]]);

void primMST(int graph[V][V]){

int parent[V];

int key[V];

bool mstSet[V];

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

Name: MANAN AGRAWAL
Roll No. : 2100910100102
 key[i] = INT_MAX, mstSet[i] = false;

key[0] = 0;

parent[0] = -1;

for (int count = 0; count < V - 1; count++) {

int u = minKey(key, mstSet);

mstSet[u] = true;

for (int v = 0; v < V; v++)

if (graph[u][v] && mstSet[v] == false

&& graph[u][v] < key[v])

parent[v] = u, key[v] = graph[u][v];

printMST(parent, graph);

int main()

int graph[V][V] = { { 0, 2, 0, 6, 0 },{ 2, 0, 3, 8, 5 }, { 0, 3, 0, 0, 7 },{ 6, 8, 0, 0, 9 },

{ 0, 5, 7, 9, 0 } };

primMST(graph);

return 0;

OUTPUT:

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 Time Complexity:

● O(V^2)

Space Complexity:

● O(V)

EXPERIMENT-17

Name: MANAN AGRAWAL

Roll No. : 2100910100102
AIM: Implement , the 0/1 Knapsack problem using Dynamic Programming method.

SOURCE CODE:

#include <stdio.h>

#include <string.h>

int findMax(int n1, int n2){

if(n1>n2) {

return n1;

} else {

return n2;

int knapsack(int W, int wt[], int val[], int n){

int K[n+1][W+1];

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

for(int w = 0; w<=W; w++) {

if(i == 0 || w == 0) {

K[i][w] = 0;

} else if(wt[i-1] <= w) {

K[i][w] = findMax(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];

Name: MANAN AGRAWAL

Roll No. : 2100910100102
}

int main(){

int val[5] = {70, 20, 50};

int wt[5] = {11, 12, 13};

int W = 30;

int len = sizeof val / sizeof val[0];

printf("Maximum Profit achieved with this knapsack: %d", knapsack(W, wt, val, len));

OUTPUT:

Time Complexity:

● O(2^N)

Space Complexity:

● O(N)

EXPERIMENT-18

Name: MANAN AGRAWAL

Roll No. : 2100910100102
AIM: Implement the Dijkstra’s Algorithm in C.

SOURCE CODE:

#include <limits.h>

#include <stdbool.h>

#include <stdio.h>

#define V 9

int minDistance(int dist[], bool sptSet[])

int min = INT_MAX, min_index;

for (int v = 0; v < V; v++)

if (sptSet[v] == false && dist[v] <= min)

min = dist[v], min_index = v;

return min_index;

void printSolution(int dist[]){

printf("Vertex \t\t Distance from Source\n");

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

printf("%d \t\t\t\t %d\n", i, dist[i]);

void dijkstra(int graph[V][V], int src){

int dist[V];

bool sptSet[V];

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

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 dist[i] = INT_MAX, sptSet[i] = false;

dist[src] = 0;

for (int count = 0; count < V - 1; count++) {

int u = minDistance(dist, sptSet);

sptSet[u] = true;

for (int v = 0; v < V; v++)

if (!sptSet[v] && graph[u][v]

&& dist[u] != INT_MAX

&& dist[u] + graph[u][v] < dist[v])

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

printSolution(dist);

int main(){

int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },{ 4, 0, 8, 0, 0, 0, 0, 11, 0 },

{ 0, 8, 0, 7, 0, 4, 0, 0, 2 }, { 0, 0, 7, 0, 9, 14, 0, 0, 0 },

{ 0, 0, 0, 9, 0, 10, 0, 0, 0 },{ 0, 0, 4, 14, 10, 0, 2, 0, 0 },

{ 0, 0, 0, 0, 0, 2, 0, 1, 6 },{ 8, 11, 0, 0, 0, 0, 1, 0, 7 },

{ 0, 0, 2, 0, 0, 0, 6, 7, 0 } };

dijkstra(graph, 0);

return 0;

OUTPUT:

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 Time Complexity:

● O(V^2)

Space Complexity:

● O(V)

EXPERIMENT-19
AIM: Implement the Naive Pattern Searching algorithm in C.
Name: MANAN AGRAWAL
Roll No. : 2100910100102
SOURCE CODE:

#include <stdio.h>

#include <string.h>

void search(char* pat, char* txt){

int M = strlen(pat);

int N = strlen(txt);

for (int i = 0; i <= N - M; i++) {

int j;

for (j = 0; j < M; j++)

if (txt[i + j] != pat[j])

break;

if (j== M)

printf("Pattern found at index %d \n", i);

int main(){

char txt[] = "AABAACAADAABAAABAA";

char pat[] = "AABA";

search(pat, txt);

return 0;

OUTPUT:

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 Time Complexity:

● Best Case: O(N)

● Worst Case: O(N^2)

Space Complexity:

● O(1)

EXPERIMENT-20

Name: MANAN AGRAWAL

Roll No. : 2100910100102
AIM: Implement the Boyer Moore algorithm in C.

SOURCE CODE:

# include <limits.h>

# include <string.h>

# include <stdio.h>

# define NO_OF_CHARS 256

int max (int a, int b) { return (a > b)? a: b; }

void badCharHeuristic( char *str, int size, int badchar[NO_OF_CHARS]) {

int i;

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

badchar[i] = -1;

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

badchar[(int) str[i]] = i;

void search( char *txt, char *pat){

int m = strlen(pat);

int n = strlen(txt);

int badchar[NO_OF_CHARS];

badCharHeuristic(pat, m, badchar);

int s = 0;

while(s <= (n - m)) {

int j = m-1;

while(j >= 0 && pat[j] == txt[s+j])

j--;

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 if (j < 0) {

printf("\n pattern occurs at shift = %d", s);

s += (s+m < n)? m-badchar[txt[s+m]] :

else

s += max(1, j - badchar[txt[s+j]]);

int main(){

char txt[] = "ABAAABCD";

char pat[] = "ABC";

search(txt, pat);

return 0;

OUTPUT:

Time Complexity:
● O(n x m)

Space Complexity:

● O(1)

EXPERIMENT-21
AIM: Implement the Rabin Karp algorithm in C.
Name: MANAN AGRAWAL
Roll No. : 2100910100102
SOURCE CODE:

#include <stdio.h>

#include <string.h>

#define d 10

void rabinKarp(char pattern[], char text[], int q) {

int m = strlen(pattern);

int n = strlen(text);

int i, j;

int p = 0;

int t = 0;

int h = 1;

for (i = 0; i < m - 1; i++)

h = (h * d) % q;

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

p = (d * p + pattern[i]) % q;

t = (d * t + text[i]) % q;

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

if (p == t) {

for (j = 0; j < m; j++) {

if (text[i + j] != pattern[j])

break;

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 }

if (j == m)

printf("Pattern is found at position: %d \n", i + 1);

if (i < n - m) {

t = (d * (t - text[i] * h) + text[i + m]) % q;

if (t < 0)

t = (t + q);

int main() {

char text[] = "ABCCDDAEFG";

char pattern[] = "CDD";

int q = 13;

rabinKarp(pattern, text, q);

OUTPUT:

EXPERIMENT-22
AIM: Implement the KMP Matcher algorithm in C.

Name: MANAN AGRAWAL

Roll No. : 2100910100102
SOURCE CODE:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void computeLPSArray(char *pattern, int m, int *lps) {

int len = 0;

int i = 1;

lps[0] = 0;

while (i < m) {

if (pattern[i] == pattern[len]) {

len++;

lps[i] = len;

i++;

} else {

if (len != 0) {

len = lps[len - 1];

} else {

lps[i] = 0;

i++;

void KMPSearch(char *text, char *pattern) {

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 int m = strlen(pattern);

int n = strlen(text);

int *lps = (int *)malloc(m * sizeof(int));

computeLPSArray(pattern, m, lps);

int i = 0;

int j = 0;

while (i < n) {

if (pattern[j] == text[i]) {

j++;

i++;

if (j == m) {

printf("Pattern found at index %d\n", i - j);

j = lps[j - 1];

} else if (i < n && pattern[j] != text[i]) {

if (j != 0) {

j = lps[j - 1];

} else {

i++;

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 free(lps);

int main() {

char text[] = "ABABDABACDABABCABAB";

char pattern[] = "ABABCABAB";

printf("Text: %s\n", text);

printf("Pattern: %s\n", pattern);

KMPSearch(text, pattern);

return 0;

OUTPUT:

Time Complexity:
● O(N+M)

Space Complexity:

● O(M)

EXPERIMENT-23
AIM: Implement the string matching for finite automata algorithm in C.

Name: MANAN AGRAWAL

Roll No. : 2100910100102
SOURCE CODE:

#include <stdio.h>

#include <string.h>

#define NO_OF_CHARS 256

int getNextState(char *pattern, int M, int state, int x) {

if (state < M && x == pattern[state])

return state + 1;

int ns, i;

for (ns = state; ns > 0; ns--) {

if (pattern[ns - 1] == x) {

for (i = 0; i < ns - 1; i++) {

if (pattern[i] != pattern[state - ns + 1 + i])

break;

if (i == ns - 1)

return ns;

return 0;

void computeTF(char *pattern, int M, int TF[][NO_OF_CHARS]) {

int state, x;

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 for (state = 0; state <= M; state++)

for (x = 0; x < NO_OF_CHARS; x++)

TF[state][x] = getNextState(pattern, M, state, x);

void search(char *text, char *pattern) {

int M = strlen(pattern);

int N = strlen(text);

int TF[M + 1][NO_OF_CHARS];

computeTF(pattern, M, TF);

int i, state = 0;

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

state = TF[state][text[i]];

if (state == M) {

printf("Pattern found at index %d\n", i - M + 1);

int main() {

char text[] = "ABABDABACDABABCABAB";

char pattern[] = "ABABCABAB";

printf("Text: %s\n", text);

printf("Pattern: %s\n", pattern);

Name: MANAN AGRAWAL

Roll No. : 2100910100102
 search(text, pattern);

return 0;

OUTPUT:

Time Complexity:
● O(M^2)

Space Complexity:

● O(M)

Name: MANAN AGRAWAL

Roll No. : 2100910100102