Experiment-1

Objective-1.1: Implementation and analysis of Linear Search and using

recursive approach.

Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int linearSearchRecursive(int arr[], int size, int target, int index) {

if (index >= size) {
return -1;
}
if (arr[index] == target) {
return index;
}
return linearSearchRecursive(arr, size, target, index + 1);
}

int main() {
int sizes[] = {100, 500, 2000, 10000, 50000, 100000};
int n_sizes = sizeof(sizes) / sizeof(sizes[0]);

printf(" Input Size (n) Linear Search Time (ms) \n");

for (int i = 0; i < n_sizes; i++) {
int size = sizes[i];
int *arr = (int *)malloc(size * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed for size %d.\n", size);
return 1;
}

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

arr[j] = j + 1;

int target = size / 2;

clock_t start, end;

start = clock();
linearSearchRecursive(arr, size, target, 0);
end = clock();

double linearTime = (double)(end - start) * 1000.0 / CLOCKS_PER_SEC;

printf(" %-18d %-24.3f \n", size, linearTime);

free(arr);
 }

return 0;
}

Output:
Input Size (n) Linear Search Time (ms)
100 0
500 0
2000 0
10000 0
50000 1
100000 2
Objective-1.1: Implementation and analysis of Binary Search and using
recursive approach.

Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int binarySearchRecursive(int arr[], int low, int high, int target) {

if (low > high) {
return -1;
}
int mid = low + (high - low) / 2;
if (arr[mid] == target) {
return mid;
}
if (arr[mid] > target) {
return binarySearchRecursive(arr, low, mid - 1, target);
}
return binarySearchRecursive(arr, mid + 1, high, target);
}

int main() {
int sizes[] = {100, 500, 2000, 10000, 50000, 100000};
int n_sizes = sizeof(sizes) / sizeof(sizes[0]);

printf(" Input Size (n) Binary Search Time (ms) \n");

for (int i = 0; i < n_sizes; i++) {
int size = sizes[i];
int *arr = (int *)malloc(size * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed for size %d.\n", size);
return 1;
}

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

arr[j] = j + 1;

int target = size / 2;

clock_t start, end;

start = clock();
binarySearchRecursive(arr, 0, size - 1, target);
end = clock();

double binaryTime = (double)(end - start) * 1000.0 / CLOCKS_PER_SEC;

printf(" %-18d %-24.3f \n", size, binaryTime);

free(arr);
 }

return 0;
}

Output:

Input Size (n) Binary Search Time (ms)

100 0
500 0
2000 0
10000 0
50000 0
100000 0
 Experiment-2

Objective-2.1 : Implementation and analysis of Insertion sort.

Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void insertSort(int arr[], int n) {

for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}

void generateArray(int arr[], int n) {

for (int i = 0; i < n; i++) {
arr[i] = rand() % 1000;
}
}

double measureTime(void (*sort_func)(int[], int), int arr[], int n) {

clock_t start, end;
start = clock();
sort_func(arr, n);
end = clock();
return ((double)(end - start) * 1000000.0 / CLOCKS_PER_SEC);
}

int main() {
int sizes[] = {500, 2000, 10000, 20000, 50000};
int n_sizes = sizeof(sizes) / sizeof(sizes[0]);

printf(" Input Size (n) Insertion Sort Time (µs) \n");

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

int size = sizes[i];
int *arr = (int *)malloc(size * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed for size %d.\n", size);
return 1;
 }

generateArray(arr, size);
double time_taken = measureTime(insertSort, arr, size);

printf(" %-18d %-24.3f \n", size, time_taken);

free(arr);
}

return 0;
}

Output:
Input Size (n) Insertion Sort Time (ms)
500 0
2000 2
10000 52
50000 1245
100000 4920
Objective-2.1 : Implementation and analysis of Selection sort.

Code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void selectSort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {
int min_idx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}

void generateArray(int arr[], int n) {

for (int i = 0; i < n; i++) {
arr[i] = rand() % 10000;
}
}

int measureTime(void (*sort_func)(int[], int), int arr[], int n) {

clock_t start, end;
start = clock();
sort_func(arr, n);
end = clock();
return ((int)(end - start));
}

int main() {
int sizes[] = {500, 2000, 10000, 50000, 100000};
int n_sizes = sizeof(sizes) / sizeof(sizes[0]);

printf(" Input Size (n) Selection Sort Time (ms) \n");

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

int size = sizes[i];
int *arr = (int *)malloc(size * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed for size %d.\n", size);
return 1;
}
 generateArray(arr, size);
int time_taken = measureTime(selectSort, arr, size);

printf(" %-18d %-24d \n", size, time_taken);

free(arr);
}

return 0;
}

Output:
Input Size (n) Selection Sort Time (ms)
500 1
2000 3
10000 72
50000 1872
100000 7248
Objective-2.1 : Implementation and analysis of Bubble sort.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void bubbleSort(int arr[], int n)

{
for (int i = 0; i < n; i++)
{
int swapped = 0;
for (int j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = 1;
}
}
if (swapped == 0)
break;
}
}

void generateArray(int arr[], int n)

{
for (int i = 0; i < n; i++)
{
arr[i] = rand() % 10000;
}
}

int measureTime(void (*sort_func)(int[], int), int arr[], int n)

{
clock_t start, end;
start = clock();
sort_func(arr, n);
end = clock();
return ((end - start) * 1000) / CLOCKS_PER_SEC; // Time in milliseconds
}

int main()
{
int sizes[] = {500, 2000, 10000, 50000, 100000};
int n_sizes = sizeof(sizes) / sizeof(sizes[0]);
 printf(" Input Size (n) Bubble Sort Time (ms) \n");

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

{
int size = sizes[i];
int arr[size];

generateArray(arr, size);
int time_taken_bubble = measureTime(bubbleSort, arr, size);

printf(" %-18d %-23d \n", size, time_taken_bubble);

}

return 0;
}

Output:
Input Size (n) Bubble Sort Time (ms)
500 0
2000 6
10000 135
50000 5737
100000 26844
 Experiment No. 3
Objective : Implementation and analysis of Merge sort and Quick sort.

Code :

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void merge(int arr[], int left, int mid, int right) {

int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];

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

L[i] = arr[left + i];
for (int j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];

int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k++] = L[i++];
} else {
arr[k++] = R[j++];
}
}

while (i < n1) arr[k++] = L[i++];

while (j < n2) arr[k++] = R[j++];
}

void mergeSort(int arr[], int left, int right) {

if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}

int partition(int arr[], int low, int high) {

int pivot = arr[high];
int i = low - 1;

for (int j = low; j < high; j++) {

 if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;

return i + 1;
}

void quickSort(int arr[], int low, int high) {

if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

void generate_random_array(int arr[], int n) {

for (int i = 0; i < n; i++) {
arr[i] = rand() % 10000;
}
}

int measure_time(void (*sort_func)(int[], int, int), int arr[], int n) {

clock_t start, end;
start = clock();
sort_func(arr, 0, n - 1);
end = clock();
return ((int)(end - start));
}

int main() {
int sizes[] = {500, 1000, 5000, 20000, 50000, 100000};
int n_sizes = sizeof(sizes) / sizeof(sizes[0]);

printf(" Input Size (n) Merge Sort Time (s) Quick Sort Time (s) \n");

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

int size = sizes[i];
int arr1[size], arr2[size];

generate_random_array(arr1, size);
int time_taken_merge = measure_time(mergeSort, arr1, size);
 generate_random_array(arr2, size);
int time_taken_quick = measure_time(quickSort, arr2, size);

printf(" %-18d %-24d %-23d \n", size, time_taken_merge, time_taken_quick);

}
return 0;
}

Output :
 Experiment No. 4

Objective : Implementation and analysis of Heap sort, Counting sort and Radix
sort.

Code :

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void heapify(int arr[], int n, int i) {

int largest = i, left = 2 * i + 1, right = 2 * i + 2;
if (left < n && arr[left] > arr[largest]) largest = left;
if (right < n && arr[right] > arr[largest]) largest = right;
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);
}
}

void countingSort(int arr[], int n) {

int max = arr[0];
for (int i = 1; i < n; i++) if (arr[i] > max) max = arr[i];

int *count = (int *)calloc(max + 1, sizeof(int)), *output = (int *)malloc(n * sizeof(int));

for (int i = 0; i < n; i++) count[arr[i]]++;
for (int i = 1; i <= max; i++) count[i] += count[i - 1];
for (int i = n - 1; i >= 0; i--) {
output[count[arr[i]] - 1] = arr[i];
count[arr[i]]--;
}
for (int i = 0; i < n; i++) arr[i] = output[i];
free(count);
free(output);
}

void countingSortRadix(int arr[], int n, int exp) {

int *output = (int *)malloc(n * sizeof(int)), count[10] = {0};
for (int i = 0; i < n; i++) count[(arr[i] / exp) % 10]++;
for (int i = 1; i < 10; i++) count[i] += count[i - 1];
for (int i = n - 1; i >= 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
for (int i = 0; i < n; i++) arr[i] = output[i];
free(output);
}

void radixSort(int arr[], int n) {

int max = arr[0];
for (int i = 1; i < n; i++) if (arr[i] > max) max = arr[i];
for (int exp = 1; max / exp > 0; exp *= 10) countingSortRadix(arr, n, exp);
}

void generateRandomArray(int arr[], int n) {

for (int i = 0; i < n; i++) arr[i] = rand() % 10000;
}

int measureTime(void (*sortFunc)(int[], int), int arr[], int n) {

clock_t start = clock();
sortFunc(arr, n);
return ((int)(clock() - start));
}

int main() {
int sizes[] = {500, 1000, 5000, 20000, 50000, 100000};
int nSizes = sizeof(sizes) / sizeof(sizes[0]);

printf(" Input Size (n) Heap Sort Time (ms) Counting Sort Time (ms) Radix Sort
Time (ms) \n");

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

int size = sizes[i], arr1[size], arr2[size], arr3[size];

generateRandomArray(arr1, size);
int heapTime = measureTime(heapSort, arr1, size);

generateRandomArray(arr2, size);
int countingTime = measureTime(countingSort, arr2, size);

generateRandomArray(arr3, size);
int radixTime = measureTime(radixSort, arr3, size);
 printf(" %-18d %-24d %-23d %-23d \n", size, heapTime, countingTime, radixTime);
}
return 0;
}

Output :
 Experiment No. 5
Objective : Implementation of Shell sort.

Code :

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void shell(int arr[], int n)

{
for (int gap = n / 2; gap > 0; gap /= 2){
for (int i = gap; i < n; i++){
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap){
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}

void generateArray(int arr[], int n){

for (int i = 0; i < n; i++){
arr[i] = rand() % 100000;
}
}
int measure(void (*sort)(int[], int), int arr[], int n){
clock_t start = clock();
sort(arr, n);
return ((int)(clock() - start));
}
int main(){
int sizes[] = {500, 1000, 5000, 20000, 50000, 100000, 300000};
int nSizes = sizeof(sizes) / sizeof(sizes[0]);
printf(" Input Size (n) Shell Sort Time (s) \n");
for (int i = 0; i < nSizes; i++){
int size = sizes[i];
int *arr = (int *)malloc(size * sizeof(int));
generateArray(arr, size);
int timeTaken = measure(shell, arr, size);
printf(" %-18d %-24d \n", size, timeTaken);
free(arr);
}
return 0;
}

Output :
 Experiment No. 6
Objective-6.1 : Implementation of Activity Selection Problem.

Code :

#include <stdio.h>

typedef struct {
int id;
int start;
int finish;
} Activity;

void sort(Activity activities[], int n) {

Activity temp;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (activities[i].finish > activities[j].finish) {
temp = activities[i];
activities[i] = activities[j];
activities[j] = temp;
}
}
}
}

void selectActivities(Activity activities[], int n) {

sort(activities, n);

printf("Selected Activities:\n");
printf(" Activity ID Start Time Finish Time|\n");

int i = 0;
printf(" a%-15d %-10d %-10d \n", activities[i].id, activities[i].start, activities[i].finish);

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

if (activities[j].start >= activities[i].finish) {
printf(" a%-15d %-10d %-10d \n", activities[j].id, activities[j].start,
activities[j].finish);
i = j;
}
}

int main() {
 int n;

printf("Enter the number of activities: ");

scanf("%d", &n);

Activity activities[n];
printf("Enter activity ID, start time, and finish time for activity\n");
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &activities[i].id, &activities[i].start, &activities[i].finish);
}

selectActivities(activities, n);

return 0;
}

Output :
Objective-6.2 : Implementation of Knapsack Problem Using Greedy Solution.

Code :

#include <stdio.h>
#include <stdlib.h>

typedef struct {
int profit;
int weight;
float ratio;
int id;
} Item;

int compare(const void *a, const void *b) {

float r1 = ((Item*)a)->ratio;
float r2 = ((Item*)b)->ratio;
if (r1 < r2) return 1;
else if (r1 > r2) return -1;
else return 0;
}

float knapsack(Item items[], int n, int W) {

for (int i = 0; i < n; i++) {
items[i].ratio = (float)items[i].profit / items[i].weight;
}

qsort(items, n, sizeof(Item), compare);

int currentWeight = 0;
float totalProfit = 0.0;

printf("Selected Items in the Knapsack:\n");

printf(" Item Number Profit Weight Profit/Weight Ratio Fraction
Included Fractional Profit \n");

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

if (currentWeight + items[i].weight <= W) {
currentWeight += items[i].weight;
totalProfit += items[i].profit;
printf(" i%-14d %-10d %-10d %-18.2f %-17.2f %-17.2f \n",
items[i].id, items[i].profit, items[i].weight, items[i].ratio, 1.0,
(float)items[i].profit);
} else {
int remainingWeight = W - currentWeight;
float fraction = (float)remainingWeight / items[i].weight;
totalProfit += items[i].profit * fraction;
 printf(" i%-14d %-10d %-10d %-18.2f %-17.2f %-17.2f \n",
items[i].id, items[i].profit, items[i].weight, items[i].ratio, fraction, items[i].profit
* fraction);
break;
}
}

return totalProfit;
}

int main() {
int n, W;

printf("Enter the number of items: ");

scanf("%d", &n);

Item items[n];
printf("Enter details for each item (Item no., weight, profit):\n");
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &items[i].id, &items[i].weight, &items[i].profit);
}

printf("Enter the maximum weight capacity of the knapsack: ");

scanf("%d", &W);

float totalProfit = knapsack(items, n, W);

printf("Total Profit: %.2f\n", totalProfit);
return 0;
}

Output :
 Experiment No. 7
Objective-7.1 : Implementation and Analysis of the 0/1 Knapsack problem
using Dynamic Programming method.

Code :

#include <stdio.h>
void knapsack(int n, int W, int weights[], int values[]) {
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 (weights[i-1] <= w) {
dp[i][w] = (values[i-1] + dp[i-1][w-weights[i-1]] > dp[i-1][w]) ?
values[i-1] + dp[i-1][w-weights[i-1]] : dp[i-1][w];
} else {
dp[i][w] = dp[i-1][w];
}
}
}
printf("\nDP Table (Maximum Profit Calculation):\n");
printf(" n\\w ");
for (int w = 0; w <= W; w++) {
printf("%4d", w);
}
printf("\n");
for (int i = 0; i <= n; i++) {
printf("%4d ", i);
for (int w = 0; w <= W; w++) {
printf("%4d", dp[i][w]);
}
printf("\n");
}
printf("\nMaximum value that can be obtained: %d\n", dp[n][W]);
int w = W;
printf("\nSelected Items:\n");
printf("Item Number | Weight | Profit | Included\n");
printf("-----------------------------------------\n");

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

if (dp[i+1][w] != dp[i][w]) {
printf("%11d | %6d | %6d | 1\n", i, weights[i], values[i]);
w -= weights[i];
} else {
printf("%11d | %6d | %6d | 0\n", i, weights[i], values[i]);
 }
}
printf("\n");
}
int main() {
int n, W;
printf("Enter the number of items: ");
scanf("%d", &n);
printf("Enter the capacity of the knapsack: ");
scanf("%d", &W);
int weights[n], values[n];
printf("Enter the weight and profit of each item (separated by space):\n");
for (int i = 0; i < n; i++) {
scanf("%d %d", &weights[i], &values[i]);
}
knapsack(n, W, weights, values);
return 0;
}

Output :
Objective-7.2 : Implementation and Analysis of LCS.
Code :

#include <stdio.h>
#include <string.h>

int lcs_length(char *X, char *Y, int m, int n) {

int dp[m+1][n+1];

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

for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else if (X[i-1] == Y[j-1]) {
dp[i][j] = dp[i-1][j-1] + 1;
} else {
dp[i][j] = (dp[i-1][j] > dp[i][j-1]) ? dp[i-1][j] : dp[i][j-1];
}
}
}
return dp[m][n];
}

void print_lcs(char *X, char *Y, int m, int n) {

int dp[m+1][n+1];

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

for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0) {
dp[i][j] = 0;
} else if (X[i-1] == Y[j-1]) {
dp[i][j] = dp[i-1][j-1] + 1;
} else {
dp[i][j] = (dp[i-1][j] > dp[i][j-1]) ? dp[i-1][j] : dp[i][j-1];
}
}
}

int index = dp[m][n];

char lcs[index + 1];
lcs[index] = '\0';

int i = m, j = n;
while (i > 0 && j > 0) {
if (X[i-1] == Y[j-1]) {
lcs[index-1] = X[i-1];
i--;
 j--;
index--;
} else if (dp[i-1][j] > dp[i][j-1]) {
i--;
} else {
j--;
}
}
printf("Longest Common Subsequence: %s\n", lcs);
}

int main() {
char X[100], Y[100];
printf("Enter the first string: ");
scanf("%s", X);
printf("Enter the second string: ");
scanf("%s", Y);
int m = strlen(X);
int n = strlen(Y);
int length = lcs_length(X, Y, m, n);
printf("Length of Longest Common Subsequence: %d\n", length);
print_lcs(X, Y, m, n);
return 0;
}

Output:
 Experiment No. 8
Objective-8.1 : Implementation of Kruskal’s Algorithm to Find MST.

Code :

#include <stdio.h>
#include <stdlib.h>

#define MAX_EDGES 100

#define MAX_VERTICES 20

typedef struct {
int u, v, weight;
} Edge;

typedef struct {
int parent[MAX_VERTICES];
int rank[MAX_VERTICES];
} DisjointSet;

Edge edges[MAX_EDGES];
DisjointSet ds;
int numEdges = 0, numVertices = 0;

void initDisjointSet(int n) {
for (int i = 0; i < n; i++) {
ds.parent[i] = i;
ds.rank[i] = 0;
}
}

int find(int u) {
if (ds.parent[u] != u) {
ds.parent[u] = find(ds.parent[u]);
}
return ds.parent[u];
}

void unionSets(int u, int v) {

int rootU = find(u);
int rootV = find(v);

if (rootU != rootV) {
if (ds.rank[rootU] > ds.rank[rootV]) {
ds.parent[rootV] = rootU;
} else if (ds.rank[rootU] < ds.rank[rootV]) {
 ds.parent[rootU] = rootV;
} else {
ds.parent[rootV] = rootU;
ds.rank[rootU]++;
}
}
}

int compareEdges(const void *a, const void *b) {

return ((Edge *)a)->weight - ((Edge *)b)->weight;
}

void kruskalMST() {
qsort(edges, numEdges, sizeof(Edge), compareEdges);

int mstWeight = 0;
printf("\nEdges in MST:\n");

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

int u = edges[i].u;
int v = edges[i].v;
int weight = edges[i].weight;

if (find(u) != find(v)) {
printf("%d -- %d == %d\n", u, v, weight);
mstWeight += weight;
unionSets(u, v);
}
}

printf("\nTotal weight of MST: %d\n", mstWeight);

}

int main() {
int e, u, v, weight;

printf("Enter the number of vertices: ");

scanf("%d", &numVertices);

printf("Enter the number of edges: ");

scanf("%d", &e);

numEdges = e;

printf("Enter the edges (u v weight) :\n");

for (int i = 0; i < e; i++) {
printf("Edge %d: ", i + 1);
scanf("%d %d %d", &u, &v, &weight);
 edges[i].u = u;
edges[i].v = v;
edges[i].weight = weight;
}

initDisjointSet(numVertices);
kruskalMST();

return 0;
}

Output:
Objective-8.2 : Implementation of Prim’s Algorithm to Find MST.
Code:
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTICES 20
#define INF 999999

int graph[MAX_VERTICES][MAX_VERTICES];
int parent[MAX_VERTICES];
int key[MAX_VERTICES];
int visited[MAX_VERTICES];
int numVertices;

void primMST() {
for (int i = 0; i < numVertices; i++) {
key[i] = INF;
visited[i] = 0;
parent[i] = -1;
}

key[0] = 0;

int totalWeight = 0;

for (int count = 0; count < numVertices; count++) {

int u = -1;
for (int v = 0; v < numVertices; v++) {
if (!visited[v] && (u == -1 || key[v] < key[u])) {
u = v;
}
}
visited[u] = 1;
if (parent[u] != -1) {
totalWeight += graph[u][parent[u]];
}
for (int v = 0; v < numVertices; v++) {
if (graph[u][v] != 0 && !visited[v] && graph[u][v] < key[v]) {
key[v] = graph[u][v];
parent[v] = u;
}
}
}
printf("\nEdges in MST:\n");
for (int i = 1; i < numVertices; i++) {
printf("%d - %d %d\n", parent[i] + 1, i + 1, graph[i][parent[i]]);
}
 printf("\nTotal weight of MST: %d\n", totalWeight);
}
int main() {
int e, u, v, weight;
printf("Enter the number of vertices: ");
scanf("%d", &numVertices);
for (int i = 0; i < numVertices; i++) {
for (int j = 0; j < numVertices; j++) {
graph[i][j] = 0;
}
}
printf("Enter the number of edges: ");
scanf("%d", &e);
printf("Enter the edges (u v weight) as space-separated values:\n");
for (int i = 0; i < e; i++) {
scanf("%d %d %d", &u, &v, &weight);
u--;
v--;
graph[u][v] = weight;
graph[v][u] = weight;
}
primMST();
return 0;
}

Output:
 Experiment No. 9
Objective-9.1 : Implementation of Warshal’s Algorithm for all pair Shortest
path.

Code :

#include <stdio.h>
#include <stdlib.h>
#define INF 999999
#define MAX_VERTICES 20
int dist[MAX_VERTICES][MAX_VERTICES];
int n;
void floydWarshall() {
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
}
void printSolution() {
printf("\nShortest distances between every pair of vertices:\n");
printf(" ");
for (int i = 0; i < n; i++) {
printf("%3d ", i + 1);
}
printf("\n");
for (int i = 0; i < n; i++) {
printf("%3d ", i + 1);
for (int j = 0; j < n; j++) {
if (dist[i][j] == INF) {
printf(" INF ");
} else {
printf("%3d ", dist[i][j]);
}
}
printf("\n");
}
}
int main() {
int e, u, v, weight;
 printf("Enter the number of vertices: ");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
dist[i][j] = 0;
} else {
dist[i][j] = INF;
}
}
}
printf("Enter the number of edges: ");
scanf("%d", &e);
printf("Enter the edges (u v weight) as space-separated values:\n");
for (int i = 0; i < e; i++) {
scanf("%d %d %d", &u, &v, &weight);
u--; v--;
dist[u][v] = weight;
}
floydWarshall();
printSolution();
return 0;
}

Output:
Objective-9.2 : Implementation of Dijkstra’s Algorithm for Single Source
Shortest path.

Code:
#include <stdio.h>
#include <stdlib.h>
#define INF 999999
#define MAX_VERTICES 20
int graph[MAX_VERTICES][MAX_VERTICES];
int dist[MAX_VERTICES];
int prev[MAX_VERTICES];
int n;
void dijkstra(int src) {
int visited[MAX_VERTICES] = {0};
for (int i = 0; i < n; i++) {
dist[i] = INF;
prev[i] = -1;
}
dist[src] = 0;
for (int count = 0; count < n - 1; count++) {
int u = -1;
for (int i = 0; i < n; i++) {
if (!visited[i] && (u == -1 || dist[i] < dist[u])) {
u = i;
}
}
visited[u] = 1;
for (int v = 0; v < n; v++) {
if (graph[u][v] != 0 && !visited[v] && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
prev[v] = u;
}}}}
void printSolution(int src) {
printf("\nShortest distances and corresponding edges from source %d:\n", src + 1);
for (int i = 0; i < n; i++) {
if (dist[i] == INF) {
printf("Vertex %d: INF\n", i + 1);
} else {
printf("Vertex %d: %d (Path: ", i + 1, dist[i]);
int current = i;
while (current != src) {
printf("%d <- ", current + 1);
current = prev[current];
}
printf("%d)", src + 1);
printf("\n");
 }
}
}
int main() {
int e, u, v, weight, src;
printf("Enter the number of vertices: ");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
graph[i][j] = 0;
}
}
printf("Enter the number of edges: ");
scanf("%d", &e);
printf("Enter the edges (u v weight) as space-separated values:\n");
for (int i = 0; i < e; i++) {
scanf("%d %d %d", &u, &v, &weight);
u--; v--;
graph[u][v] = weight;
graph[v][u] = weight;
}
printf("Enter the source vertex: ");
scanf("%d", &src);
src--;
dijkstra(src);
printSolution(src);
return 0;
}

Output:
 Experiment No. 10
Objective-10.1 : Implementation of N Queen Problem using Backtracking.

Code :

#include <stdio.h>
#include <stdbool.h>

#define MAX 20

int board[MAX][MAX];
int n;

void printSolution() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", board[i][j]);
}
printf("\n");
}
printf("\n");
}

bool isSafe(int row, int col) {

for (int i = 0; i < row; i++) {
if (board[i][col] == 1) {
return false;
}
}
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 1) {
return false;
}
}
for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (board[i][j] == 1) {
return false;
}
}
return true;
}

bool solveNQueens(int row) {

if (row >= n) {
 return true;
}
for (int col = 0; col < n; col++) {
if (isSafe(row, col)) {
board[row][col] = 1;
if (solveNQueens(row + 1)) {
return true;
}
board[row][col] = 0;
}
}
return false;
}

int main() {
printf("Enter the value of N: ");
scanf("%d", &n);

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

for (int j = 0; j < n; j++) {
board[i][j] = 0;
}
}

if (solveNQueens(0) == true) {
printf("Solution to the N-Queens problem is:\n");
printSolution();
} else {
printf("Solution does not exist for N = %d\n", n);
}

return 0;
}

Output:
Objective-9.2 : Implementation of Sum of Subset Problem using Backtracking

Code:
#include <stdio.h>
#define MAX 20
int set[MAX];
int n, targetSum;
int solution[MAX];
void printSolution() {
printf("Subset with sum %d: { ", targetSum);
for (int i = 0; i < n; i++) {
if (solution[i]) {
printf("%d ", set[i]);
}
}
printf("}\n");
}
void sumOfSubset(int i, int currentSum) {
if (currentSum == targetSum) {
printSolution();
return;
}
if (i == n || currentSum > targetSum) {
return;
}
solution[i] = 1;
sumOfSubset(i + 1, currentSum + set[i]);

solution[i] = 0;
sumOfSubset(i + 1, currentSum);
}
int main() {
printf("Enter the number of elements in the set: ");
scanf("%d", &n);
printf("Enter the elements of the set: ");
for (int i = 0; i < n; i++) {
scanf("%d", &set[i]);
}
printf("Enter the target sum: ");
scanf("%d", &targetSum);
for (int i = 0; i < n; i++) {
solution[i] = 0;
}
sumOfSubset(0, 0);
return 0;
}

Output: