1. AIzaSyDpb8vS10K7OfXvQ_6w6DK4rb2PdZ46VRU

2. AIzaSyAvIMQ5u3JBKjEUCcgzy_y3uAlQW60xBzU

3. AIzaSyCklw9RYh0cnH_pCu-xh5gWXufY7oNfhao

4. AIzaSyDQbBa2s6uC1yxdPRf9Z_xX6NLTD-aUK5A

5. AIzaSyDgkjloFPAaVeDU2BRUbBebtbdLD0Oy1iw

6. AIzaSyAzI3Wx6qD7huc8mncpA_RaMI7Xc452EEE

7. AIzaSyBXWZGODaYuDqJiwS13xxUo0zSg3NZlBKM

8. AIzaSyDraS5N6IrkvWLIEc4p5fB6Q5yM8F6p7bE

9. AIzaSyCp-jn8jawHuLXqtkMf69lXpTwnM_o2tHw

10. AIzaSyBcffLFD2gCRstMwiaj7Wb8FOXuG884-OQ

Topological sort

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

#define MAX 100

int graph[MAX][MAX]; int in_degree[MAX]; int queue[MAX]; int front = -1, rear = -1; int visited[MAX]; int n;

// Function prototypes void insertEdge(int src, int dest); void createGraph(); void topologicalSort(); void enqueue(int vertex); int dequeue(); int isEmptyQueue();

int main() { int choice; while (1) { printf("\n=========== Topological Sort Menu ===========\n"); printf("1. Create Graph\n"); printf("2. Display Adjacency Matrix\n"); printf("3. Topological Sort\n"); printf("4. Exit\n"); printf("=============================================\n"); printf("Enter your choice: "); scanf("%d", &choice);

    switch (choice) {
    case 1:
        createGraph();
        break;
    case 2:
        printf("Adjacency Matrix:\n");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                printf("%d ", graph[i][j]);
            }
            printf("\n");
        }
        break;
    case 3:
        topologicalSort();
        break;
    case 4:
        exit(0);
    default:
        printf("Invalid choice. Please try again.\n");
    }
}
return 0;

}

// Function to create the graph void createGraph() { int edges, src, dest; printf("Enter number of vertices: "); scanf("%d", &n); printf("Enter number of edges: "); scanf("%d", &edges);

// Initialize matrices and arrays
for (int i = 0; i < n; i++) {
    in_degree[i] = 0;
    visited[i] = 0;
    for (int j = 0; j < n; j++) {
        graph[i][j] = 0;
    }
}

printf("Enter edges (source destination):\n");
for (int i = 0; i < edges; i++) {
    scanf("%d %d", &src, &dest);
    insertEdge(src, dest);
}

}

void insertEdge(int src, int dest) { if (src >= n || dest >= n || src < 0 || dest < 0) { printf("Invalid edge!\n"); return; } graph[src][dest] = 1; in_degree[dest]++; }

void topologicalSort() { int i; // Enqueue vertices with in-degree 0 for (i = 0; i < n; i++) { if (in_degree[i] == 0) { enqueue(i); } }

int count = 0;
printf("Topological Order: ");
while (!isEmptyQueue()) {
    int vertex = dequeue();
    printf("%d ", vertex);
    count++;

    for (i = 0; i < n; i++) {
        if (graph[vertex][i] == 1) {
            in_degree[i]--;
            if (in_degree[i] == 0) {
                enqueue(i);
            }
        }
    }
}

if (count != n) {
    printf("\nCycle detected! Topological sort not possible.\n");
}
printf("\n");

}

void enqueue(int vertex) { if (rear == MAX - 1) return; if (front == -1) front = 0; queue[++rear] = vertex; }

int dequeue() { if (front == -1 || front > rear) return -1; return queue[front++]; }

int isEmptyQueue() { return front == -1 || front > rear; }

johnson trotter

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

#define LEFT -1 #define RIGHT 1 #define MAX 10

typedef struct { int value; int dir; } Element;

Element perm[MAX]; int n;

// Function prototypes void generatePermutations(); int getMobileIndex(); void swap(int i, int j); void displayPermutation(); void menu();

int main() { menu(); return 0; }

void menu() { int choice;

while (1) {
    printf("\n========= Johnson-Trotter Menu =========\n");
    printf("1. Enter n and Generate Permutations\n");
    printf("2. Exit\n");
    printf("========================================\n");
    printf("Enter your choice: ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        printf("Enter the number of elements (n ≤ %d): ", MAX);
        scanf("%d", &n);
        if (n < 1 || n > MAX) {
            printf("Invalid value of n!\n");
            break;
        }
        generatePermutations();
        break;
    case 2:
        exit(0);
    default:
        printf("Invalid choice. Try again.\n");
    }
}

}

void generatePermutations() { for (int i = 0; i < n; i++) { perm[i].value = i + 1; perm[i].dir = LEFT; }

displayPermutation();

while (1) {
    int mobileIndex = getMobileIndex();
    if (mobileIndex == -1)
        break;

    int swapIndex = mobileIndex + perm[mobileIndex].dir;
    swap(mobileIndex, swapIndex);

    for (int i = 0; i < n; i++) {
        if (perm[i].value > perm[swapIndex].value)
            perm[i].dir *= -1;
    }

    displayPermutation();
}

}

int getMobileIndex() { int mobile = 0; int index = -1;

for (int i = 0; i < n; i++) {
    int dir = perm[i].dir;
    int neighbor = i + dir;
    if (neighbor >= 0 && neighbor < n && perm[i].value > perm[neighbor].value) {
        if (perm[i].value > mobile) {
            mobile = perm[i].value;
            index = i;
        }
    }
}

return index;

}

void swap(int i, int j) { Element temp = perm[i]; perm[i] = perm[j]; perm[j] = temp; }

void displayPermutation() { for (int i = 0; i < n; i++) printf("%d ", perm[i].value); printf("\n"); }

merge sort

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

#define MAX 100000

int arr[MAX]; int temp[MAX]; int n;

// Function prototypes void mergeSort(int left, int right); void merge(int left, int mid, int right); void inputArray(); void displayArray(); void generateRandomArray(); void menu();

int main() { menu(); return 0; }

void menu() { int choice; clock_t start, end; double cpu_time_used;

while (1) {
    printf("\n========= Merge Sort Menu =========\n");
    printf("1. Enter elements manually\n");
    printf("2. Generate random elements\n");
    printf("3. Display array\n");
    printf("4. Sort and compute time\n");
    printf("5. Exit\n");
    printf("===================================\n");
    printf("Enter your choice: ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        inputArray();
        break;
    case 2:
        generateRandomArray();
        break;
    case 3:
        displayArray();
        break;
    case 4:
        start = clock();
        mergeSort(0, n - 1);
        end = clock();
        cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
        printf("Sorted array:\n");
        displayArray();
        printf("Time taken to sort %d elements: %f seconds\n", n, cpu_time_used);
        break;
    case 5:
        exit(0);
    default:
        printf("Invalid choice. Try again.\n");
    }
}

}

void inputArray() { printf("Enter the number of elements: "); scanf("%d", &n); if (n > MAX) { printf("Limit exceeded. Max allowed: %d\n", MAX); return; } printf("Enter %d integers:\n", n); for (int i = 0; i < n; i++) scanf("%d", &arr[i]); }

void generateRandomArray() { printf("Enter number of random elements to generate: "); scanf("%d", &n); if (n > MAX) { printf("Limit exceeded. Max allowed: %d\n", MAX); return; }

srand(time(NULL));
for (int i = 0; i < n; i++)
    arr[i] = rand() % 100000;
printf("Random array generated.\n");

}

void displayArray() { for (int i = 0; i < n; i++) { printf("%d ", arr[i]); if ((i + 1) % 10 == 0) printf("\n"); } printf("\n"); }

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

void merge(int left, int mid, int right) { int i = left, j = mid + 1, k = left;

while (i <= mid && j <= right) {
    if (arr[i] <= arr[j])
        temp[k++] = arr[i++];
    else
        temp[k++] = arr[j++];
}

while (i <= mid)
    temp[k++] = arr[i++];

while (j <= right)
    temp[k++] = arr[j++];

for (int l = left; l <= right; l++)
    arr[l] = temp[l];

}

quick sort

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

#define MAX 100000

int arr[MAX]; int n;

// Function prototypes void quickSort(int low, int high); int partition(int low, int high); void inputArray(); void displayArray(); void generateRandomArray(); void menu();

int main() { menu(); return 0; }

void menu() { int choice; clock_t start, end; double cpu_time_used;

while (1) {
    printf("\n========= Quick Sort Menu =========\n");
    printf("1. Enter elements manually\n");
    printf("2. Generate random elements\n");
    printf("3. Display array\n");
    printf("4. Sort and compute time\n");
    printf("5. Exit\n");
    printf("===================================\n");
    printf("Enter your choice: ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        inputArray();
        break;
    case 2:
        generateRandomArray();
        break;
    case 3:
        displayArray();
        break;
    case 4:
        start = clock();
        quickSort(0, n - 1);
        end = clock();
        cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
        printf("Sorted array:\n");
        displayArray();
        printf("Time taken to sort %d elements: %f seconds\n", n, cpu_time_used);
        break;
    case 5:
        exit(0);
    default:
        printf("Invalid choice. Try again.\n");
    }
}

}

void inputArray() { printf("Enter the number of elements: "); scanf("%d", &n); if (n > MAX) { printf("Limit exceeded. Max allowed: %d\n", MAX); return; } printf("Enter %d integers:\n", n); for (int i = 0; i < n; i++) scanf("%d", &arr[i]); }

void generateRandomArray() { printf("Enter number of random elements to generate: "); scanf("%d", &n); if (n > MAX) { printf("Limit exceeded. Max allowed: %d\n", MAX); return; }

srand(time(NULL));
for (int i = 0; i < n; i++)
    arr[i] = rand() % 100000;
printf("Random array generated.\n");

}

void displayArray() { for (int i = 0; i < n; i++) { printf("%d ", arr[i]); if ((i + 1) % 10 == 0) printf("\n"); } printf("\n"); }

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

int partition(int low, int high) { int pivot = arr[high]; int i = low - 1, temp;

for (int j = low; j < high; j++) {
    if (arr[j] <= pivot) {
        i++;
        // swap arr[i] and arr[j]
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

// swap arr[i+1] and pivot (arr[high])
temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;

return i + 1;

}

0/1 knapsack

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

#define MAX_ITEMS 1000 #define MAX_CAPACITY 10000

int weights[MAX_ITEMS], values[MAX_ITEMS]; int n, capacity;

// Function prototypes int knapsack(); void inputItems(); void generateRandomItems(); void menu();

int main() { menu(); return 0; }

void menu() { int choice; clock_t start, end; double cpu_time_used; int maxValue;

while (1) {
    printf("\n========= 0/1 Knapsack Menu =========\n");
    printf("1. Enter items manually\n");
    printf("2. Generate random items\n");
    printf("3. Solve Knapsack and compute time\n");
    printf("4. Exit\n");
    printf("======================================\n");
    printf("Enter your choice: ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        inputItems();
        break;
    case 2:
        generateRandomItems();
        break;
    case 3:
        start = clock();
        maxValue = knapsack();
        end = clock();
        cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
        printf("Maximum value in knapsack of capacity %d = %d\n", capacity, maxValue);
        printf("Time taken: %f seconds\n", cpu_time_used);
        break;
    case 4:
        exit(0);
    default:
        printf("Invalid choice. Try again.\n");
    }
}

}

void inputItems() { printf("Enter number of items: "); scanf("%d", &n); if (n > MAX_ITEMS) { printf("Limit exceeded. Max allowed: %d\n", MAX_ITEMS); return; } printf("Enter knapsack capacity: "); scanf("%d", &capacity); printf("Enter weights and values of %d items:\n", n); for (int i = 0; i < n; i++) { printf("Item %d - Weight: ", i + 1); scanf("%d", &weights[i]); printf("Item %d - Value: ", i + 1); scanf("%d", &values[i]); } }

void generateRandomItems() { printf("Enter number of items to generate: "); scanf("%d", &n); if (n > MAX_ITEMS) { printf("Limit exceeded. Max allowed: %d\n", MAX_ITEMS); return; } printf("Enter knapsack capacity: "); scanf("%d", &capacity); if (capacity > MAX_CAPACITY) { printf("Capacity too large. Max allowed: %d\n", MAX_CAPACITY); return; } srand(time(NULL)); for (int i = 0; i < n; i++) { weights[i] = rand() % 100 + 1; // 1 to 100 values[i] = rand() % 200 + 1; // 1 to 200 } printf("Random items generated.\n"); }

int knapsack() { int dp[n + 1][capacity + 1];

for (int i = 0; i <= n; i++) {
    for (int w = 0; w <= capacity; 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];
    }
}

return dp[n][capacity];

}

floyds

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

#define MAX 100 #define INF 99999

int n; // number of vertices int graph[MAX][MAX];

// Function prototypes void inputGraph(); void generateRandomGraph(); void displayGraph(int g[MAX][MAX]); void floydWarshall(); void menu();

int main() { menu(); return 0; }

void menu() { int choice; clock_t start, end; double cpu_time_used;

while (1) {
    printf("\n====== Floyd's All-Pair Shortest Path Menu ======\n");
    printf("1. Enter graph manually\n");
    printf("2. Generate random graph\n");
    printf("3. Display current graph\n");
    printf("4. Compute shortest paths using Floyd's algorithm\n");
    printf("5. Exit\n");
    printf("=================================================\n");
    printf("Enter your choice: ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        inputGraph();
        break;
    case 2:
        generateRandomGraph();
        break;
    case 3:
        printf("Current Graph (Adjacency Matrix):\n");
        displayGraph(graph);
        break;
    case 4:
        start = clock();
        floydWarshall();
        end = clock();
        cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
        printf("Time taken: %f seconds\n", cpu_time_used);
        break;
    case 5:
        exit(0);
    default:
        printf("Invalid choice. Try again.\n");
    }
}

}

void inputGraph() { printf("Enter number of vertices (max %d): ", MAX); scanf("%d", &n); if (n > MAX) { printf("Number of vertices too large! Max is %d\n", MAX); return; }

printf("Enter adjacency matrix (use %d for no direct edge):\n", INF);
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        scanf("%d", &graph[i][j]);
        if (i == j)
            graph[i][j] = 0;
    }
}

}

void generateRandomGraph() { printf("Enter number of vertices (max %d): ", MAX); scanf("%d", &n); if (n > MAX) { printf("Number of vertices too large! Max is %d\n", MAX); return; }

srand(time(NULL));
// Generate random weighted graph, 0 distance for self loops and INF for no edge randomly
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        if (i == j)
            graph[i][j] = 0;
        else {
            // Randomly decide if edge exists (70% chance)
            if ((rand() % 100) < 70) {
                graph[i][j] = (rand() % 20) + 1;  // weights 1 to 20
            } else {
                graph[i][j] = INF;
            }
        }
    }
}
printf("Random graph generated.\n");

}

void displayGraph(int g[MAX][MAX]) { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (g[i][j] == INF) printf("INF "); else printf("%3d ", g[i][j]); } printf("\n"); } }

void floydWarshall() { int dist[MAX][MAX];

// Initialize distance matrix same as graph
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        dist[i][j] = graph[i][j];

// Floyd-Warshall Algorithm
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];
            }
        }
    }
}

printf("All-Pair Shortest Path matrix:\n");
displayGraph(dist);

}

Prims

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

#define MAX 100 #define INF INT_MAX

int n; // number of vertices int graph[MAX][MAX];

// Function prototypes void inputGraph(); void generateRandomGraph(); void displayGraph(); void primMST(); void menu();

int main() { menu(); return 0; }

void menu() { int choice; clock_t start, end; double cpu_time_used;

while (1) {
    printf("\n====== Prim's MST Menu ======\n");
    printf("1. Enter graph manually\n");
    printf("2. Generate random graph\n");
    printf("3. Display current graph\n");
    printf("4. Find MST using Prim's algorithm\n");
    printf("5. Exit\n");
    printf("=============================\n");
    printf("Enter your choice: ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        inputGraph();
        break;
    case 2:
        generateRandomGraph();
        break;
    case 3:
        printf("Current Graph (Adjacency Matrix):\n");
        displayGraph();
        break;
    case 4:
        start = clock();
        primMST();
        end = clock();
        cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
        printf("Time taken: %f seconds\n", cpu_time_used);
        break;
    case 5:
        exit(0);
    default:
        printf("Invalid choice. Try again.\n");
    }
}

}

void inputGraph() { printf("Enter number of vertices (max %d): ", MAX); scanf("%d", &n); if (n > MAX) { printf("Number of vertices too large! Max is %d\n", MAX); return; }

printf("Enter adjacency matrix (enter 0 if no edge):\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        scanf("%d", &graph[i][j]);
        if (i == j)
            graph[i][j] = 0;
        else if (graph[i][j] == 0)
            graph[i][j] = INF;  // No edge
    }
}

}

void generateRandomGraph() { printf("Enter number of vertices (max %d): ", MAX); scanf("%d", &n); if (n > MAX) { printf("Number of vertices too large! Max is %d\n", MAX); return; }

srand(time(NULL));
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        if (i == j)
            graph[i][j] = 0;
        else if (j < i)
            graph[i][j] = graph[j][i]; // symmetric for undirected
        else {
            // 70% chance edge exists
            if ((rand() % 100) < 70) {
                graph[i][j] = (rand() % 20) + 1;
            } else {
                graph[i][j] = INF;
            }
        }
    }
}
printf("Random graph generated.\n");

}

void displayGraph() { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (graph[i][j] == INF) printf("INF "); else printf("%3d ", graph[i][j]); } printf("\n"); } }

int minKey(int key[], int mstSet[]) { int min = INF, min_index = -1;

for (int v = 0; v < n; v++) {
    if (mstSet[v] == 0 && key[v] < min) {
        min = key[v];
        min_index = v;
    }
}
return min_index;

}

void primMST() { int parent[MAX]; // Array to store constructed MST int key[MAX]; // Key values used to pick minimum weight edge int mstSet[MAX]; // To represent set of vertices included in MST

// Initialize all keys as infinite and mstSet[] as false
for (int i = 0; i < n; i++) {
    key[i] = INF;
    mstSet[i] = 0;
}

// Always include first vertex in MST.
key[0] = 0;     // Make key 0 so that this vertex is picked first
parent[0] = -1; // First node is root of MST

for (int count = 0; count < n - 1; count++) {
    int u = minKey(key, mstSet);

    mstSet[u] = 1;  // Include u in MST

    for (int v = 0; v < n; v++) {
        // graph[u][v] is non zero only for adjacent vertices of u
        // mstSet[v] is false for vertices not yet included in MST
        // Update key only if graph[u][v] is smaller than key[v]
        if (graph[u][v] && mstSet[v] == 0 && graph[u][v] < key[v]) {
            parent[v] = u;
            key[v] = graph[u][v];
        }
    }
}

printf("Edge \tWeight\n");
int total_weight = 0;
for (int i = 1; i < n; i++) {
    if(parent[i] != -1) {
        printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);
        total_weight += graph[i][parent[i]];
    }
}
printf("Total weight of MST: %d\n", total_weight);

}

krushkal

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

#define MAX 100 #define INF 99999

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

int n; // Number of vertices int graph[MAX][MAX]; Edge edges[MAX * MAX]; int edgeCount = 0;

// Disjoint Set (Union-Find) structure int parent[MAX];

void inputGraph(); void generateRandomGraph(); void displayGraph(); void kruskalMST(); int find(int i); void unionSets(int u, int v); void menu();

int main() { menu(); return 0; }

void menu() { int choice; clock_t start, end; double cpu_time_used;

while (1) {
    printf("\n====== Kruskal's MST Menu ======\n");
    printf("1. Enter graph manually\n");
    printf("2. Generate random graph\n");
    printf("3. Display current graph\n");
    printf("4. Find MST using Kruskal's algorithm\n");
    printf("5. Exit\n");
    printf("===============================\n");
    printf("Enter your choice: ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        inputGraph();
        break;
    case 2:
        generateRandomGraph();
        break;
    case 3:
        printf("Current Graph (Adjacency Matrix):\n");
        displayGraph();
        break;
    case 4:
        start = clock();
        kruskalMST();
        end = clock();
        cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
        printf("Time taken: %f seconds\n", cpu_time_used);
        break;
    case 5:
        exit(0);
    default:
        printf("Invalid choice. Try again.\n");
    }
}

}

void inputGraph() { printf("Enter number of vertices (max %d): ", MAX); scanf("%d", &n); if (n > MAX) { printf("Number of vertices too large! Max is %d\n", MAX); return; }

edgeCount = 0;
printf("Enter adjacency matrix (enter 0 if no edge):\n");
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        scanf("%d", &graph[i][j]);
        if (i == j)
            graph[i][j] = 0;
        else if (graph[i][j] == 0)
            graph[i][j] = INF;
    }
}

// Extract edges from upper triangle (undirected)
edgeCount = 0;
for (int i = 0; i < n; i++) {
    for (int j = i+1; j < n; j++) {
        if (graph[i][j] != INF) {
            edges[edgeCount].u = i;
            edges[edgeCount].v = j;
            edges[edgeCount].weight = graph[i][j];
            edgeCount++;
        }
    }
}

}

void generateRandomGraph() { printf("Enter number of vertices (max %d): ", MAX); scanf("%d", &n); if (n > MAX) { printf("Number of vertices too large! Max is %d\n", MAX); return; }

srand(time(NULL));
// Generate symmetric weighted adjacency matrix for undirected graph
for (int i = 0; i < n; i++) {
    graph[i][i] = 0;
    for (int j = i+1; j < n; j++) {
        if ((rand() % 100) < 70) {
            int w = (rand() % 20) + 1; // weight 1 to 20
            graph[i][j] = w;
            graph[j][i] = w;
        } else {
            graph[i][j] = INF;
            graph[j][i] = INF;
        }
    }
}

// Extract edges
edgeCount = 0;
for (int i = 0; i < n; i++)
    for (int j = i+1; j < n; j++)
        if (graph[i][j] != INF) {
            edges[edgeCount].u = i;
            edges[edgeCount].v = j;
            edges[edgeCount].weight = graph[i][j];
            edgeCount++;
        }

printf("Random graph generated.\n");

}

void displayGraph() { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (graph[i][j] == INF) printf("INF "); else printf("%3d ", graph[i][j]); } printf("\n"); } }

int find(int i) { while (parent[i] != i) i = parent[i]; return i; }

void unionSets(int u, int v) { int set_u = find(u); int set_v = find(v); parent[set_u] = set_v; }

int compareEdges(const void* a, const void* b) { Edge* e1 = (Edge*)a; Edge* e2 = (Edge*)b; return e1->weight - e2->weight; }

void kruskalMST() { // Initialize disjoint sets for (int i = 0; i < n; i++) parent[i] = i;

// Sort edges by weight
qsort(edges, edgeCount, sizeof(Edge), compareEdges);

Edge mst[MAX];
int mstSize = 0;
int totalWeight = 0;

for (int i = 0; i < edgeCount && mstSize < n - 1; i++) {
    int u_set = find(edges[i].u);
    int v_set = find(edges[i].v);

    if (u_set != v_set) {
        mst[mstSize++] = edges[i];
        totalWeight += edges[i].weight;
        unionSets(u_set, v_set);
    }
}

printf("Edges in MST:\n");
printf("U - V : Weight\n");
for (int i = 0; i < mstSize; i++) {
    printf("%d - %d : %d\n", mst[i].u, mst[i].v, mst[i].weight);
}
printf("Total weight of MST: %d\n", totalWeight);

}

fractional knapsack

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

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

int compare(const void *a, const void *b) { Item _item1 = (Item _)a; Item _item2 = (Item _)b; if (item2->ratio > item1->ratio) return 1; else if (item2->ratio < item1->ratio) return -1; else return 0; }

void fractionalKnapsack(Item items[], int n, float capacity) { // Sort items by profit/weight ratio qsort(items, n, sizeof(Item), compare);

float totalProfit = 0.0;
float remainingCapacity = capacity;

printf("\nItem\tWeight\tProfit\tRatio\tTaken\n");

for (int i = 0; i < n; i++) {
    if (items[i].weight <= remainingCapacity) {
        // Take full item
        remainingCapacity -= items[i].weight;
        totalProfit += items[i].profit;
        printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\n", items[i].id, items[i].weight, items[i].profit, items[i].ratio, items[i].weight);
    } else {
        // Take fraction of item
        float fraction = remainingCapacity / items[i].weight;
        totalProfit += items[i].profit * fraction;
        printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\n", items[i].id, items[i].weight, items[i].profit, items[i].ratio, remainingCapacity);
        remainingCapacity = 0;
        break;
    }
}
printf("\nTotal profit in knapsack = %.2f\n", totalProfit);

}

int main() { int n; float capacity;

printf("Enter number of items: ");
scanf("%d", &n);

Item items[n];

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

printf("Enter knapsack capacity: ");
scanf("%f", &capacity);

fractionalKnapsack(items, n, capacity);

return 0;

}

djikstra

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

#define MAX 100 #define INF INT_MAX

int n; // number of vertices int graph[MAX][MAX];

void dijkstra(int src, int dist[], int visited[]) { for (int i = 0; i < n; i++) { dist[i] = INF; visited[i] = 0; } dist[src] = 0;

for (int count = 0; count < n - 1; count++) {
    // Find vertex with minimum dist not visited
    int minDist = INF, u = -1;
    for (int v = 0; v < n; v++) {
        if (!visited[v] && dist[v] <= minDist) {
            minDist = dist[v];
            u = v;
        }
    }

    if (u == -1) break; // All reachable vertices processed

    visited[u] = 1;

    // Update dist of neighbors of u
    for (int v = 0; v < n; v++) {
        if (!visited[v] && graph[u][v] != 0 && graph[u][v] != INF
            && dist[u] != INF && dist[u] + graph[u][v] < dist[v]) {
            dist[v] = dist[u] + graph[u][v];
        }
    }
}

}

void inputGraph() { printf("Enter number of vertices (max %d): ", MAX); scanf("%d", &n);

printf("Enter adjacency matrix (0 if no edge):\n");
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) {
        scanf("%d", &graph[i][j]);
        if (i != j && graph[i][j] == 0)
            graph[i][j] = INF;
    }

}

int main() { int source; int dist[MAX], visited[MAX];

inputGraph();

printf("Enter source vertex (0 to %d): ", n - 1);
scanf("%d", &source);

dijkstra(source, dist, visited);

printf("\nVertex\tDistance from Source %d\n", source);
for (int i = 0; i < n; i++) {
    if (dist[i] == INF)
        printf("%d \t\t %s\n", i, "INF");
    else
        printf("%d \t\t %d\n", i, dist[i]);
}

return 0;

}

N-Queens

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

#define MAX 20

int board[MAX][MAX]; int N;

void printBoard() { for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) printf("%s ", board[i][j] ? "Q" : "."); printf("\n"); } printf("\n"); }

int isSafe(int row, int col) { int i, j;

// Check this column on upper rows
for (i = 0; i < row; i++)
    if (board[i][col]) return 0;

// Check upper left diagonal
for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
    if (board[i][j]) return 0;

// Check upper right diagonal
for (i = row, j = col; i >= 0 && j < N; i--, j++)
    if (board[i][j]) return 0;

return 1;

}

int solveNQueens(int row) { if (row == N) { printBoard(); return 1; // return 1 to find all solutions; return 0 to stop at first }

int res = 0;
for (int col = 0; col < N; col++) {
    if (isSafe(row, col)) {
        board[row][col] = 1;
        res = solveNQueens(row + 1) || res;
        board[row][col] = 0;  // backtrack
    }
}
return res;

}

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

if (N < 1 || N > MAX) {
    printf("N must be between 1 and %d\n", MAX);
    return 1;
}

// Initialize board
for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++)
        board[i][j] = 0;

if (!solveNQueens(0)) {
    printf("No solutions exist for N = %d\n", N);
}

return 0;

}