EXPERIMENT NO.

1
Problem Statement: Write a program to implement binary search using a recursive approach.

Code:
#include <stdio.h>
int binarySearch(int arr[], int left, int right, int target) {
if (left > right)
return -1;
int mid = left + (right - left) / 2;
if (arr[mid] == target)
return mid;
else if (arr[mid] > target)
return binarySearch(arr, left, mid - 1, target);
else
return binarySearch(arr, mid + 1, right, target);
}
int main() {
int arr[] = {2, 4, 7, 10, 14};
int n = sizeof(arr) / sizeof(arr[0]);
int target = 10;
int result = binarySearch(arr, 0, n - 1, target);
if (result != -1)
printf("Found at index %d\n", result);
else
printf("Not found\n");
return 0;
}
 EXPERIMENT NO. 2
Problem Statement: Write a program to implement the Merge Sort algorithm.

Code:
#include <stdio.h>
void merge(int arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (int i = 0; i < n1; i++) L[i] = arr[l + i];
for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
int i = 0, j = 0, k = l;
while (i < n1 && j < n2)
arr[k++] = (L[i] <= R[j]) ? L[i++] : R[j++];
while (i < n1) arr[k++] = L[i++];
while (j < n2) arr[k++] = R[j++];
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
mergeSort(arr, 0, n - 1);
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
return 0;
}
 EXPERIMENT NO. 3
Problem Statement: Write a program to implement the Heap Sort algorithm.

Code:
#include <stdio.h>
void heapify(int arr[], int n, int i) {
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && arr[l] > arr[largest]) largest = l;
if (r < n && arr[r] > arr[largest]) largest = r;
if (largest != i) {
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heapify(arr, n, largest);
}
}
void heapSort(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (int i = n - 1; i > 0; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
}
}
int main() {
int arr[] = {4, 10, 3, 5, 1};
int n = sizeof(arr) / sizeof(arr[0]);
heapSort(arr, n);
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
return 0;
}
 EXPERIMENT NO. 4
Problem Statement: Write a program to implement Strassen's matrix multiplication algorithm.

Code:
#include <stdio.h>
void strassen(int A[2][2], int B[2][2], int C[2][2]) {
int M1 = (A[0][0] + A[1][1]) * (B[0][0] + B[1][1]);
int M2 = (A[1][0] + A[1][1]) * B[0][0];
int M3 = A[0][0] * (B[0][1] - B[1][1]);
int M4 = A[1][1] * (B[1][0] - B[0][0]);
int M5 = (A[0][0] + A[0][1]) * B[1][1];
int M6 = (A[1][0] - A[0][0]) * (B[0][0] + B[0][1]);
int M7 = (A[0][1] - A[1][1]) * (B[1][0] + B[1][1]);

C[0][0] = M1 + M4 - M5 + M7;
C[0][1] = M3 + M5;
C[1][0] = M2 + M4;
C[1][1] = M1 - M2 + M3 + M6;
}
int main() {
int A[2][2] = {{1, 2}, {3, 4}}, B[2][2] = {{5, 6}, {7, 8}}, C[2][2];
strassen(A, B, C);
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++)
printf("%d ", C[i][j]);
printf("\n");
}
return 0;
}
 EXPERIMENT NO. 5
Problem Statement: Write a program to implement finding the maximum and minimum elements in

an array using a divide and conquer approach.

Code:
#include <stdio.h>
void findMinMax(int arr[], int low, int high, int* min, int* max) {
if (low == high) {
*min = *max = arr[low];
return;
}
if (high == low + 1) {
if (arr[low] < arr[high]) {
*min = arr[low];
*max = arr[high];
} else {
*min = arr[high];
*max = arr[low];
}
return;
}
int mid = (low + high) / 2, min1, max1, min2, max2;
findMinMax(arr, low, mid, &min1, &max1);
findMinMax(arr, mid + 1, high, &min2, &max2);
*min = (min1 < min2) ? min1 : min2;
*max = (max1 > max2) ? max1 : max2;
}
int main() {
int arr[] = {100, 45, 3, 78, 90, 23};
int min, max;
findMinMax(arr, 0, 5, &min, &max);
printf("Min: %d\nMax: %d\n", min, max);
return 0;
}
 EXPERIMENT NO. 6
Problem Statement: Write a program to implement the Fractional Knapsack problem using a greedy

approach.

Code:
#include <stdio.h>
struct Item {
int value, weight;
};
void swap(struct Item* a, struct Item* b) {
struct Item t = *a;
*a = *b;
*b = t;
}
void fractionalKnapsack(struct Item items[], int n, int W) {
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - i - 1; j++)
if ((float)items[j].value/items[j].weight <
(float)items[j+1].value/items[j+1].weight)
swap(&items[j], &items[j+1]);

float totalValue = 0.0;

for (int i = 0; i < n && W > 0; i++) {
if (items[i].weight <= W) {
W -= items[i].weight;
totalValue += items[i].value;
} else {
totalValue += items[i].value * ((float)W / items[i].weight);
break;
}
}
printf("Maximum value = %.2f\n", totalValue);
}
int main() {
struct Item items[] = {{60, 10}, {100, 20}, {120, 30}};
int W = 50;
fractionalKnapsack(items, 3, W);
return 0;
}
 EXPERIMENT NO. 7
Problem Statement: Write a program to implement the Job Sequencing with Deadlines problem

using a greedy approach.

Code:
#include <stdio.h>
#include <string.h>
struct Job {
char id;
int deadline;
int profit;
};
void swap(struct Job* a, struct Job* b) {
struct Job t = *a;
*a = *b;
*b = t;
}
int min(int a, int b) {
return (a < b) ? a : b;
}
void jobSequencing(struct Job jobs[], int n) {
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - i - 1; j++)
if (jobs[j].profit < jobs[j+1].profit)
swap(&jobs[j], &jobs[j+1]);

int result[n], slot[n];

memset(slot, 0, sizeof(slot));

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

for (int j = min(n, jobs[i].deadline) - 1; j >= 0; j--) {
if (!slot[j]) {
result[j] = i;
slot[j] = 1;
break;
}
}
}

printf("Selected jobs: ");

for (int i = 0; i < n; i++)
if (slot[i])
printf("%c ", jobs[result[i]].id);
printf("\n");
}
int main() {
struct Job jobs[] = {{'a', 2, 100}, {'b', 1, 19}, {'c', 2, 27}, {'d', 1, 25}, {'e',
3, 15}};
jobSequencing(jobs, 5);
 return 0;
}
 EXPERIMENT NO. 8
Problem Statement: Write a program to implement the 0/1 Knapsack problem using dynamic

programming.

Code:
#include <stdio.h>
int max(int a, int b) {
return (a > b) ? a : b;
}
int knapsack(int W, int wt[], int val[], int n) {
int dp[n+1][W+1];
for (int i = 0; i <= n; i++) {
for (int w = 0; w <= W; w++) {
if (i == 0 || w == 0)
dp[i][w] = 0;
else if (wt[i-1] <= w)
dp[i][w] = max(val[i-1] + dp[i-1][w-wt[i-1]], dp[i-1][w]);
else
dp[i][w] = dp[i-1][w];
}
}
return dp[n][W];
}
int main() {
int val[] = {60, 100, 120};
int wt[] = {10, 20, 30};
int W = 50;
int n = sizeof(val)/sizeof(val[0]);
printf("Maximum value: %d\n", knapsack(W, wt, val, n));
return 0;
}
 EXPERIMENT NO. 9
Problem Statement: Write a program to implement the Longest Common Subsequence (LCS)

problem using dynamic programming.

Code:
#include <stdio.h>
int max(int a, int b) { return (a > b) ? a : b; }
int lcs(char* X, char* Y, int m, int n) {
int L[m+1][n+1];
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X[i-1] == Y[j-1])
L[i][j] = 1 + L[i-1][j-1];
else
L[i][j] = max(L[i-1][j], L[i][j-1]);
}
}
return L[m][n];
}
int main() {
char X[] = "AGGTAB";
char Y[] = "GXTXAYB";
printf("Length of LCS: %d\n", lcs(X, Y, 6, 7));
return 0;
}
 EXPERIMENT NO. 10
Problem Statement: Write a program to implement the Matrix Chain Multiplication problem using

dynamic programming.

Code:
#include <stdio.h>
#include <limits.h>
int matrixChain(int p[], int n) {
int m[n][n];
for (int i = 1; i < n; i++) m[i][i] = 0;
for (int L = 2; L < n; L++) {
for (int i = 1; i < n - L + 1; i++) {
int j = i + L - 1;
m[i][j] = INT_MAX;
for (int k = i; k < j; k++) {
int q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
if (q < m[i][j]) m[i][j] = q;
}
}
}
return m[1][n-1];
}
int main() {
int arr[] = {1, 2, 3, 4};
int n = sizeof(arr)/sizeof(arr[0]);
printf("Minimum multiplications: %d\n", matrixChain(arr, n));
return 0;
}
 EXPERIMENT NO. 11
Problem Statement: Write a program to implement the Floyd-Warshall algorithm for finding all-pairs

shortest paths.

Code:
#include <stdio.h>
#define INF 99999
#define V 4
void floydWarshall(int graph[V][V]) {
int dist[V][V];
for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++)
dist[i][j] = graph[i][j];
for (int k = 0; k < V; k++)
for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++)
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (dist[i][j] == INF)
printf("INF ");
else
printf("%d ", dist[i][j]);
}
printf("\n");
}
}
int main() {
int graph[V][V] = {
{0, 5, INF, 10},
{INF, 0, 3, INF},
{INF, INF, 0, 1},
{INF, INF, INF, 0}
};
floydWarshall(graph);
return 0;
}
 EXPERIMENT NO. 12
Problem Statement: Write a program to implement the Graph M-Coloring problem using

backtracking.

Code:
#include <stdio.h>
#define V 4
int graph[V][V] = {
{0, 1, 1, 1},
{1, 0, 1, 0},
{1, 1, 0, 1},
{1, 0, 1, 0}
};
void printSolution(int color[]) {
for (int i = 0; i < V; i++)
printf(" %d ", color[i]);
printf("\n");
}
int isSafe(int v, int color[], int c) {
for (int i = 0; i < V; i++)
if (graph[v][i] && color[i] == c)
return 0;
return 1;
}
int graphColoringUtil(int m, int color[], int v) {
if (v == V) return 1;
for (int c = 1; c <= m; c++) {
if (isSafe(v, color, c)) {
color[v] = c;
if (graphColoringUtil(m, color, v + 1)) return 1;
color[v] = 0;
}
}
return 0;
}
void graphColoring(int m) {
int color[V] = {0};
if (!graphColoringUtil(m, color, 0))
printf("Solution does not exist\n");
else
printSolution(color);
}
int main() {
int m = 3;
graphColoring(m);
return 0;
}