QUICK SORT int j = partition(a, p, q);

quicksort(a, p, j - 1);
#include <stdio.h> quicksort(a, j + 1, q);
#include <time.h> }}
#include <stdlib.h> void main() {
#define MAX 100 printf("Enter number of
clock_t start, end; elements: ");
float time_taken; scanf("%d", &n);
int a[100000], n, i, j, temp; printf("Generating
void swap(int* a, int* b) { random array
int temp = *a; elements...\n");
*a = *b; for (i = 0; i < n; i++) {
*b = temp; a[i] = rand() % 10000;
} }
int partition(int a[], int p, printf("Sorting
int r) { array...\n");
int pivotindex = p + start = clock();
rand() % (r - p + 1); quicksort(a, 0, n - 1);
int pivot = a[pivotindex]; end = clock();
int i = p - 1; printf("Sorted Array
swap(&a[pivotindex], elements are:\n");
&a[r]); for (i = 0; i < n; i++) {
for (j = p; j < r; j++) { printf("%d\t", a[i]);
if (a[j] < pivot) { }
i++; time_taken = (float)(end
swap(&a[i], &a[j]); - start) / CLOCKS_PER_SEC;
}} printf("\nTime taken
swap(&a[i + 1], &a[r]); is %f seconds\n",
return i + 1;} time_taken);
void quicksort(int a[], int p, }
int q) {
if (p < q) {
Floyd’s
#include <stdio.h>
#include <stdlib.h> printf("Enter the cost
int min(int a, int b) { adjacency matrix (use
return (a < b) ? a : b; 9999 for infinity):\n");
} for (i = 0; i < n; i++) {
void FLOYD(int n, int for (j = 0; j < n; j++) {
cost[20][20], int D[20][20]) scanf("%d",
{ &cost[i][j]);
int i, j, k; }}
for (i = 0; i < n; i++) { printf("Cost adjacency
for (j = 0; j < n; j++) { matrix:\n");
D[i][j] = cost[i][j]; for (i = 0; i < n; i++) {
}} for (j = 0; j < n; j++) {
vertices printf("%d\t",
for (k = 0; k < n; k++) { cost[i][j]);
for (i = 0; i < n; i++) { }
for (j = 0; j < n; j++) { printf("\n");
D[i][j] = }
min(D[i][j], D[i][k] + FLOYD(n, cost, D);
D[k][j]); printf("Shortest path
} matrix:\n");
} for (i = 0; i < n; i++) {
} for (j = 0; j < n; j++) {
} printf("%d\t",
int main() { D[i][j]);
int n, cost[20][20], }
D[20][20], i, j; printf("\n");
printf("Enter the }
number of vertices: "); return 0;
scanf("%d", &n); }
Warshal
#include<stdio.h> void warshall(int
a[10][10],int n)
void warshall(int {
a[10][10],int); int i,j,k;
for(k=1;k<=n;k++)
int main() for(j=1;j<=n;j++)
{ for(i=1;i<=n;i++)
int i,j,n,a[10][10];
printf("enter the number a[i][j]=a[i][j]||(a[i][k]&&a[
of vertices\n"); k][j]);
scanf("%d",&n); }
printf("enter the
adjacency matrix\n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
printf("(%d,%d):",i,j);
scanf("%d",&a[i][j]);
}
warshall(a,n);
printf("all pair distance
matrix\n");
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
printf("%d\t",a[i][j]);
printf("\n");
}
return 0;
}
GReedy knapsack
int currentweight = 0;
#include <stdio.h> max_profit = 0.0;
#define Max 60 for (i = 0; i < n; i++) {
int p[Max], w[Max]; if (currentweight + w[i]
float x[Max]; <= m) {
double max_profit; x[i] = 1;
int n, m, i; currentweight += w[i];
void greedyknapsack(int n, max_profit += p[i];
int w[], int p[], int m) { } else {
double ratio[Max]; x[i] = (m -
for (i = 0; i < n; i++) { currentweight) /
ratio[i] = (double)p[i] / (double)w[i];
w[i]; max_profit += x[i] * p[i];
} break;
for (i = 0; i < n - 1; i++) { } }
for (int j = i + 1; j < n; printf("Solution vector
j++) { for greedy method:\n");
if (ratio[i] < ratio[j]) for (i = 0; i < n; i++) {
{ printf("%f\t", x[i]);
double temp = }
ratio[i]; printf("\nOptimal
ratio[i] = ratio[j]; solution for greedy
ratio[j] = temp; method = %f\n",
int temp2 = w[i]; max_profit);
w[i] = w[j];
w[j] = temp2; int main() {
temp2 = p[i]; printf("Enter the
p[i] = p[j]; number of objects: ");
p[j] = temp2; scanf("%d", &n);
}}}
 printf("Enter the
capacity of the knapsack:
");
scanf("%d", &m);

printf("Enter the profit

matrix:\n");
for (i = 0; i < n; i++) {
scanf("%d", &p[i]);
}

printf("Enter the weight

matrix:\n");
for (i = 0; i < n; i++) {
scanf("%d", &w[i]);
}

greedyknapsack(n, w, p,
m);

return 0;
}
 present = 1;
SUBSET for (j = 1; j <= n; j++)
{
#include <stdio.h> if (x[j] == 1)
#include <math.h> printf("%d ",
void sub_set(long int num, a[j]);
int n, int x[]); }
int main() { printf("} = %d\n", d);
int a[50], x[50], n, d, }
sum, present = 0; }
long int i, j; if (!present)
printf("Enter the printf("Solution does
number of elements: "); not exist\n");
scanf("%d", &n);
printf("Enter the return 0;
elements:\n"); }
for (i = 1; i <= n; i++) void sub_set(long int num,
scanf("%d", &a[i]); int n, int x[]) {
printf("Enter the sum of long int i;
the subset: "); for (i = 1; i <= n; i++)
scanf("%d", &d); x[i] = 0;
for (i = 1; i < pow(2, n);
i++) { for (i = n; num != 0; i--) {
sub_set(i, n, x); x[i] = num % 2;
sum = 0; num = num / 2;
for (j = 1; j <= n; j++) { }
if (x[j] == 1) }
sum += a[j];
}
if (d == sum) {
printf("Subset is { ");
using Dijkstra's
algorithm. for (i = 1; i <= n; i++) {
printf("The shortest
#include <stdio.h> path between vertex %d
#define INF 999 to %d is %d\n", s, i, dist[i]);
#define MAX 10 }

int n, cost[MAX][MAX], return 0;

dist[MAX]; }

void readmatrix(int n); int min(int a, int b) {

int min(int a, int b); return (a > b) ? b : a;
void shortest_path(int n, }
int s);
void readmatrix(int n) {
int main() { int i, j;
int i, s; for (i = 1; i <= n; i++) {
printf("Enter the for (j = 1; j <= n; j++) {
number of vertices: "); printf("(%d,%d): ", i,
scanf("%d", &n); j);
scanf("%d",
printf("Enter the cost &cost[i][j]);
adjacency matrix (999 for if (cost[i][j] == 0)
infinite):\n"); cost[i][j] = INF;
readmatrix(n); }
}
printf("Enter the source }
vertex: ");
scanf("%d", &s); void shortest_path(int n,
int s) {
shortest_path(n, s); int vis[MAX], c, u, k, i;
 for (i = 1; i <= n; i++) {
vis[i] = 0;
dist[i] = cost[s][i];
}
dist[s] = 0;
vis[s] = 1;

for (k = 1; k < n; k++) {

c = INF;
for (i = 1; i <= n; i++) {
if (vis[i] == 0 &&
dist[i] < c) {
c = dist[i];
u = i;
}
}
vis[u] = 1;

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

if (!vis[i]) {
dist[i] =
min(dist[i], dist[u] +
cost[u][i]);
}
}
}
}
N_QUEENS return 1;
}
#include <stdio.h> void n_queen(int k, int n) {
#include <stdlib.h> int i, j, p;
#define MAX 20 for (i = 1; i <= n; i++) {
int count = 0, x[MAX]; if (place(k, i)) {
void n_queen(int, int); x[k] = i;
int place(int, int); if (k == n) {
int main() { count++;
int n; printf("Solution %d:\n",
printf("Enter the count);
number of queens: "); for (j = 1; j <= n;
scanf("%d", &n); j++) {
n_queen(1, n); for (p = 1; p <=
if (count == 0) { n; p++) {
printf("No solutions if (x[j] == p) {
are found\n"); printf("Q\t");
} else { } else {
printf("Number of printf("O\t");
solutions found: %d\n", }
count); }
} printf("\n");
return 0; }
} printf("\n");
int place(int k, int i) { } else {
int j; n_queen(k + 1, n);
for (j = 1; j < k; j++) { }
if ((x[j] == i) || (abs(x[j] }
- i) == abs(j - k))) { }
return 0; }
}}
 if (v[j] == 0 &&
PRIMS c[u][j] < d[j]) {
#include <stdio.h> d[j] = c[u][j];
#include <limits.h> ver[j] = u;
#define MAX 10 }
#define INF 9999 }
int prim(int c[MAX][MAX], }
int n, int s) { return sum;
int v[MAX], i, j, sum = 0, }
ver[MAX], d[MAX], min, u; int main() {
for (i = 1; i <= n; i++) { int c[MAX][MAX], i, j, res,
ver[i] = s; s, n;
d[i] = c[s][i]; printf("Enter number of
v[i] = 0; nodes: ");
} scanf("%d", &n);
v[s] = 1; printf("Enter the graph
for (i = 1; i <= n - 1; i++) { data (adjacency
min = INF; matrix):\n");
for (j = 1; j <= n; j++) { for (i = 1; i <= n; i++) {
if (v[j] == 0 && d[j] for (j = 1; j <= n; j++) {
< min) { scanf("%d", &c[i][j]);
min = d[j]; }
u = j; }
} printf("Enter the source
} node: ");
v[u] = 1; scanf("%d", &s);
sum += d[u]; res = prim(c, n, s);
printf("\n%d -> %d printf("\nCost = %d\n",
sum = %d", ver[u], u, sum); res);
for (j = 1; j <= n; j++) { return 0;
}