Daaaa

COLLEGE OF TECHNOLOGY AND ENGINEERING
NAME :- Mukul Bharat SUBJECT :- CS 362 (PCC): DESIGN & ANALYSIS OF ALGORITHMS
CLASS :- B.TECH. III YEAR
Program 9.
Object: Write a program to implement Counting sort.
#include <iostream>
#include <vector>
void countingSort(std::vector<int>& arr) {

if (arr.empty()) return;
// Find the maximum element in the array

int max_element = *std::max_element(arr.begin(), arr.end());
// Create a count array to store the count of each element

std::vector<int> count(max_element + 1, 0);
// Count the occurrences of each element

for (int num : arr) {
count[num]++;
}
// Update the count array to store the cumulative count of each element
for (int i = 1; i <= max_element; ++i) {
count[i] += count[i - 1];
}
// Create a temporary array to store the sorted output

std::vector<int> output(arr.size());
// Build the sorted array

for (int i = arr.size() - 1; i >= 0; --i) {
output[count[arr[i]] - 1] = arr[i];
count[arr[i]]--;
}
// Copy the sorted elements back to the original array

for (size_t i = 0; i < arr.size(); ++i) {
arr[i] = output[i];
}
}
int main() {
std::vector<int> arr = {4, 2, 2, 8, 3, 3, 1};
std::cout << "Original array:";
std::cout << " " << num;
}
std::cout << std::endl;
countingSort(arr);
std::cout << "Sorted array:";

}
return 0;
}
OUTPUT:-
PS C:\Users\mukul\OneDrive\Desktop\New folder> cd "c:\Users\mukul\OneDrive\Desktop\New folder\" ; if ($?) {

g++ countingsort.cpp -o countingsort } ; if ($?) { .\countingsort }
Original array: 4 2 2 8 3 3 1
Sorted array: 1 2 2 3 3 4 8
Program 10.
Object: Write a program to implement radix sort.
#include <iostream>
#include <vector>
#include <algorithm>
int getMax(std::vector<int>& arr) {

int max = arr[0];
for (size_t i = 1; i < arr.size(); i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
void countingSort(std::vector<int>& arr, int exp) {

std::vector<int> output(arr.size());
std::vector<int> count(10, 0);
// Store count of occurrences in count[]

count[(arr[i] / exp) % 10]++;
}
for (int i = 1; i < 10; i++) {

count[i] += count[i - 1];
}
// Build the output array

for (int i = arr.size() - 1; i >= 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
// Copy the output array to arr[], so that arr[] now

// contains sorted numbers according to the current digit
arr[i] = output[i];
}
}
void radixSort(std::vector<int>& arr) {
int max = getMax(arr);

for (int exp = 1; max / exp > 0; exp *= 10) {
countingSort(arr, exp);
}
}
int main() {
std::vector<int> arr = {170, 45, 75, 90, 802, 24, 2, 66};
}
radixSort(arr);

}
return 0;
}
OUTPUT:-
PS C:\Users\mukul\OneDrive\Desktop\New folder> cd "c:\Users\mukul\OneDrive\Desktop\New folder\"
; if ($?) { g++ redix.cpp -o redix } ; if ($?) { .\redix }
Original array: 170 45 75 90 802 24 2 66
Sorted array: 2 24 45 66 75 90 170 802
PS C:\Users\mukul\OneDrive\Desktop\New folder>
Program 11.
Object: Write a program to implement BUCKET sort.
#include <iostream>
#include <vector>
void bucketSort(std::vector<double>& arr) {

int n = arr.size();
// Create buckets
std::vector<std::vector<double>> buckets(n);
// Put array elements in different buckets

for (int i = 0; i < n; i++) {
int bucket_index = n * arr[i];
buckets[bucket_index].push_back(arr[i]);
}
// Sort individual buckets

for (int i = 0; i < n; i++) {
std::sort(buckets[i].begin(), buckets[i].end());
}
// Concatenate all buckets into arr[]

int index = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < buckets[i].size(); j++) {
arr[index++] = buckets[i][j];
}
}
int main() {
int n;
std::cout << "Enter the number of elements: ";
std::cin >> n;
std::vector<double> arr(n);
std::cout << "Enter the elements (between 0 and 1): ";
for (int i = 0; i < n; i++) {
std::cin >> arr[i];
}

for (double num : arr) {
}
bucketSort(arr);

for (double num : arr) {
}
return 0;
}
OUTPUT:-

; if ($?) { g++ BUCKET.cpp -o BUCKET } ; if ($?) { .\BUCKET }
Enter the number of elements: 5
Enter the elements (between 0 and 1): 0 0.2 0.1 0.6 0.4
Original array: 0 0.2 0.1 0.6 0.4
Sorted array: 0 0.1 0.2 0.4 0.6
Program 12.
Object: Write a program to Implement Longest Common Subsequence.
Code:
#include <iostream>
#include <cstring> // for memset
using namespace std;
const int MAX = 1e5;
void lcs(string a, string b, int n, int m) {

int dp[n + 1][m + 1];
memset(dp, 0, sizeof(dp)); // Initialize dp array with zeros
for (int i = 1; i <= n; i++) {

for (int j = 1; j <= m; j++) {
if (a[i - 1] == b[j - 1]) {
dp[i][j] = 1 + dp[i - 1][j - 1];
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
int index = dp[n][m];

char lcs[index + 1];
lcs[index] = '\0';
int i = n, j = m;
while (i > 0 && j > 0) {
if (a[i - 1] == b[j - 1]) {
lcs[index - 1] = a[i - 1];
i--;
j--;
index--;
} else if (dp[i - 1][j] > dp[i][j - 1]) {
i--;
} else {

j--;
}
}
cout << "Total length of LCS is: " << dp[n][m] << endl;
cout << "LCS of " << a << " and " << b << " is " << lcs << endl;
}
int main() {
string a, b;
cout << "Enter string 1: " << endl;
cin >> a;
cout << "Enter string 2: " << endl;
cin >> b;
int n = a.length();
int m = b.length();
lcs(a, b, n, m);
return 0;
}
OUTPUT:
PS C:\Users\mukul\OneDrive\Desktop\New folder> cd "c:\Users\mukul\OneDrive\Desktop\New folder\" ; if ($?) { g++
lcs.cpp - lcs } ; if ($?) { .\lcs }
Enter string 1:
abcd
Enter string 2:
defgabc
Total length of LCS is: 3
LCS of abcd and defgabc is abc
Program 13.
Object: Write a program to implement matrix chain multiplication.
#include <iostream>
#include <climits>
#include <vector>
// Function to find the minimum number of scalar multiplications needed

// to compute the matrix chain product of matrices from i to j
int matrixChainOrder(vector<int>& p, int n) {
vector<vector<int>> dp(n, vector<int>(n, 0));
// dp[i][j] will store the minimum number of scalar multiplications

// needed to compute the matrix chain product from matrix i to matrix j
for (int len = 2; len < n; len++) {
for (int i = 1; i < n - len + 1; i++) {
int j = i + len - 1;
dp[i][j] = INT_MAX;
for (int k = i; k < j; k++) {
int cost = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j];
if (cost < dp[i][j]) {
dp[i][j] = cost;
}
}
}
}
// The result is stored in dp[1][n-1]

return dp[1][n - 1];
}
int main() {
vector<int> dimensions = {10, 30, 5, 60};
int n = dimensions.size();
cout << "Minimum number of scalar multiplications needed: " << matrixChainOrder(dimensions, n)
<< endl;
return 0;
}
OUTPUT :-
; if ($?) { g++ BUCKET.cpp -o BUCKET } ; if ($?) { .\BUCKET }
Minimum number of scalar multiplications needed: 4500
Program 14.
Object: WAP to Implement Travelling Salesman Problem
Code:
// CPP program to implement traveling salesman
// problem using naive approach.
#include <bits/stdc++.h>
#define V 4
// implementation of traveling Salesman Problem

int travllingSalesmanProblem(int graph[][V], int s)
{
// store all vertex apart from source vertex
vector<int> vertex;
for (int i = 0; i < V; i++)
if (i != s)
vertex.push_back(i);
// store minimum weight Hamiltonian Cycle.

int min_path = INT_MAX;
do
{
// store current Path weight(cost)

int current_pathweight = 0;
// compute current path weight

int k = s;
for (int i = 0; i < vertex.size(); i++)
{
current_pathweight += graph[k][vertex[i]];
k = vertex[i];
}
current_pathweight += graph[k][s];
// update minimum
min_path = min(min_path, current_pathweight);
} while (
next_permutation(vertex.begin(), vertex.end()));
return min_path;
}
// Driver Code
int main()
{15, 35, 0, 30},

{20, 25, 30, 0}};
int s = 0;
cout << travllingSalesmanProblem(graph, s) << endl;
return 0;
}
OUTPUT:

tsp.cpp
tsp } ; if ($?) { .\tsp }
80
Program 15.
Object: WAP to Implement 01 knapsack problem using Dynamic programming.
Code:
const int MAX = 1e5;
int max(int a, int b) { return (a > b) ? a : b; }

int dp[100][1000];
int knapsack(int W, int wt[], int val[], int n)
{
if (n < 0)
return 0;
if (dp[n][W] != -1)
{
return dp[n][W];
}
if (wt[n] > W)
{
dp[n][W] = knapsack(W, wt, val, n - 1);
return dp[n][W];
}
else
{
dp[n][W] = max(knapsack(W, wt, val, n - 1), val[n] + knapsack(W - wt[n], wt, val, n - 1));
return dp[n][W];
}
}
int main()
{
memset(dp, -1, sizeof(dp));
cout << "Enter number of elements " << endl;
int n, W;
cin >> n;
int w[n], v[n];
cout << "Weight of every elements " << endl;
for (int i = 0; i < n; i++)
{
cin >> w[i];
}
cout << "Value of every elements respective to weights: " << endl;
for (int i = 0; i < n; i++)
{
cin >> v[i];
}
cout << "Total Weights: " << endl;
cin >> W;
cout << "Max Value: " << endl;

cout << knapsack(W, w, v, n);
return 0;
}
OUTPUT:
knap.cpp -o knap } ; if ($?) { .\knap }
Enter number of elements

4
Weight of every elements
3457
Value of every elements respective to weights:
10 30 40 20
Total Weights:
10
Max Value:
70
Program 16.
Object: Write a program to implement Fractional k - napsack.
#include <iostream>
#include <vector>
// Structure to represent an item

struct Item {
int weight;
int value;
double density;
Item(int w, int v) : weight(w), value(v) {

density = (double)value / weight;
}
};
// Comparison function to sort items by their density in non-increasing order

bool compare(Item a, Item b) {
return a.density > b.density;
}
// Function to solve the fractional knapsack problem

double fractionalKnapsack(int capacity, vector<Item>& items) {
// Sort items by their density in non-increasing order
sort(items.begin(), items.end(), compare);
double totalValue = 0.0;

int currentWeight = 0;
for (int i = 0; i < items.size(); ++i) {

if (currentWeight + items[i].weight <= capacity) {
// Take the whole item if it fits into the knapsack
totalValue += items[i].value;
currentWeight += items[i].weight;
} else {
// Take a fraction of the item if it doesn't fit completely
int remainingWeight = capacity - currentWeight;
totalValue += items[i].density * remainingWeight;
break; // No need to consider remaining items
}
}
return totalValue;
}
int main() {
int capacity, n;
cout << "Enter the capacity of the knapsack: ";
cin >> capacity;
cout << "Enter the number of items: ";

cin >> n;
vector<Item> items;
cout << "Enter weight and value for each item:" << endl;
for (int i = 0; i < n; ++i) {
int weight, value;
cin >> weight >> value;
items.push_back(Item(weight, value));
}
double maxValue = fractionalKnapsack(capacity, items);

cout << "Maximum value in the knapsack: " << maxValue << endl;
return 0;
}
OUTPUT:-
Enter the capacity of the knapsack: 12
Enter the number of items: 5
Enter weight and value for each item:
1
2
5
6
8
8
9
4
5
10
Maximum value in the knapsack: 19
Program 17.
Object: Write a program to implement BIN tracking.
#include <iostream>
#include <vector>
void firstFit(vector<int>& items, int binCapacity) {

vector<int> bins;
for (int item : items) {
bool packed = false;
for (int& bin : bins) {
if (bin + item <= binCapacity) {
bin += item;
packed = true;
break;
}
}
if (!packed) {
bins.push_back(item);
}
}
cout << "Number of bins used: " << bins.size() << endl;
cout << "Items packed into bins:" << endl;
for (int i = 0; i < bins.size(); ++i) {
cout << "Bin " << i + 1 << ": ";
cout << bins[i] << " ";
cout << endl;
}
}
int main() {
vector<int> items = {4, 8, 1, 4, 2, 5};
int binCapacity = 10;
cout << "Bin capacity: " << binCapacity << endl;
firstFit(items, binCapacity);
return 0;
}
OUTPUT:-
; if ($?) { g++ BIN.CPP -o BIN } ; if ($?) { .\BIN }
Bin capacity: 10
Number of bins used: 3
Items packed into bins:
Bin 1: 9
Bin 2: 10
Bin 3: 5
Program 18.
Object: Write a program to implement DFS.
Code:
void dfs(int node, vector<vector<int>> adj, vector<bool> &vis)

{
vis[node] = true;
cout << node << " ";
for (auto x : adj[node])
{
if (vis[x])
{
;
}
else
{
dfs(x, adj, vis);
}
}
}
void DFS(vector<vector<int>> adj, int n)
{
vector<bool> vis(n + 1, false);
for (int i = 0; i < n; i++)

{
if (!vis[i])
{
dfs(i, adj, vis);
}
}
}
int main()
{
int n, m;
cin >> n >> m;
vector<vector<int>> adj(n);
for (int i = 0; i < m; i++)
{
int u, v;
cin >> u >> v;
adj[u].push_back(v);
}
cout << "DFS of Given Graph is as follows: " << endl;
DFS(adj, n);
return 0;
}
OUTPUT:
dfs.cpp -o dfs } ; if ($?) { .\dfs }
56
01
02
13
14
24
34
DFS of Given Graph is as follows:
01342
Program 19.
Object: Write a program to implement BFS.
Code:
vector<int> bfsOfGraph(int V, vector<int> adj[])

{
vector<int> ans;
vector<bool> vis(V + 1, false);
queue<int> q;
q.push(0);
vis[0] = true;
while (!q.empty())
{
int node = q.front();
q.pop();
ans.push_back(node);
for (auto it : adj[node])
{
if (!vis[it])
{
q.push(it);
vis[it] = true;
}
}
}
return ans;
}
int main()
{
int V, E;
cin >> V >> E;
vector<int> adj[V];
for (int i = 0; i < E; i++)
{
int u, v;
cin >> u >> v;
adj[u].push_back(v);
}
vector<int> ans = bfsOfGraph(V, adj);
cout << "BFS of Given Graph is as follows" << endl;
for (int i = 0; i < ans.size(); i++)
{
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
OUTPUT:
bfs.cpp -o bfs } ; if ($?) { .\bfs }
56
01
02
13
14
24
34
BFS of Given Graph is as follows
01234
Program 20.
Object: Write a program to implement Prim's algorithm.
Code:
// Function to find sum of weights of edges of the Minimum Spanning Tree.
void spanningTree(int V, vector<vector<int>> adj[])
{
int n = V;
int parent[n];
int keys[n];
bool mstSet[n];
for (int i = 0; i < n; i++)
{
parent[i] = -1;
keys[i] = INT_MAX;
mstSet[i] = false;
}
keys[0] = 0;
parent[0] = -1;
for (int i = 0; i < n - 1; i++)
{
int mini = INT_MAX, u;
for (int v = 0; v < n; v++)

{
if (mstSet[v] == false && keys[v] < mini)
{
mini = keys[v];
u = v;
}
}
mstSet[u] = true;
for (auto it : adj[u])
{
int v = it[0];
int weight = it[1];
if (mstSet[v] == false && weight < keys[v])

{
parent[v] = u, keys[v] = weight;
}
}
}
int sum = 0;
for (int i = 0; i < n; i++)
{
sum += keys[i];
}
cout << "Edge \tWeight\n";

for (int i = 1; i < V; i++)
cout << parent[i] << " - " << i << " \t" << keys[i] << " \n";
cout << "Total Weight of MST" << endl;
cout << sum << endl;
}
int main()
{
int V, E;
cin >> V >> E;
vector<vector<int>> adj[V];
int i = 0;
while (i++ < E)
{
int u, v, w;
cin >> u >> v >> w;
vector<int> t1, t2;
t1.push_back(v);
t1.push_back(w);
adj[u].push_back(t1);
t2.push_back(u);
t2.push_back(w);
adj[v].push_back(t2);
}
spanningTree(V, adj);
return 0;
}
OUTPUT:
prime.cpp -o prime } ; if ($?) { .\prime }
57
012
036
123
138
145
247
349
Edge Weight
0-1 2
1-2 3
0-3 6
1-4 5
Total Weight of MST
16
Program 21.
Object: Write a program to implement Kruskal's Algorithm.
Code:
struct node
{
int u;
int v;
int wt;
node(int first, int second, int weight)
{
u = first;
v = second;
wt = weight;
}
};
bool comp(node a, node b)
{
return a.wt < b.wt;
}
int findPar(int u, vector<int> &parent)
{
if (u == parent[u])
return u;
return parent[u] = findPar(parent[u], parent);
}
void unionn(int u, int v, vector<int> &parent, vector<int> &rank)
{
u = findPar(u, parent);
v = findPar(v, parent);
if (rank[u] < rank[v])
{
parent[u] = v;
}
else if (rank[v] < rank[u])
{
parent[v] = u;
}
else
{
parent[v] = u;
rank[u]++;
}
}
void kruskals(vector<node> edges, int N)
{
sort(edges.begin(), edges.end(), comp);
vector<int> parent(N);
for (int i = 0; i < N; i++)
parent[i] = i;
vector<int> rank(N, 0);
int cost = 0;
vector<pair<pair<int, int>, int>> mst;
for (auto it : edges)
{if (findPar(it.v, parent) != findPar(it.u, parent)){cost += it.wt;mst.push_back({{it.u,
it.v},it.wt});unionn(it.u, it.v, parent, rank);}}
cout << "Edge \tWeight\n";
for (auto it : mst)
cout << it.first.first << " - " << it.first.second << " \t" << it.second << " \n";
cout << "Total weight of MST" << endl;
cout << cost << endl;
}
int main()
{
int N, m;
cin >> N >> m;
vector<node> edges;
for (int i = 0; i < m; i++)
{
int u, v, wt;
cin >> u >> v >> wt;
edges.push_back(node(u, v, wt));
}
kruskals(edges, N);
return 0;
}
OUTPUT:
kruskal.cpp -o kruskal } ; if ($?) { .\kruskal }
57
012
036
123
138
145
247
349
Edge Weight
0-1 2
1-2 3
1-4 5
0-3 6
Total weight of MST
16
Program 22.
Object: Write a program to implement Dijkstra algorithm.
Code:
vector<int> dijkstra(int n, vector<vector<int>> adj[], int src)
{
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
vector<int> distTo(n, INT_MAX);
distTo[src] = 0;
pq.push(make_pair(0, src));
while (!pq.empty())
{
int dist = pq.top().first;
int prev = pq.top().second;
pq.pop();
for (auto it : adj[prev])
{
int next = it[0];
int nextDist = it[1];
if (distTo[next] > distTo[prev] + nextDist)

{
distTo[next] = distTo[prev] + nextDist;
pq.push(make_pair(distTo[next], next));
}
}
}
return distTo;
}
int main()
{
int V, E;
cin >> V >> E;
vector<vector<int>> adj[V];
int i = 0;
while (i++ < E)
{
int u, v, w;
cin >> u >> v >> w;
vector<int> t1, t2;
t1.push_back(v);
t1.push_back(w);
adj[u].push_back(t1);
t2.push_back(u);
t2.push_back(w);
adj[v].push_back(t2);
}
int S;
cin >> S;
vector<int> res = dijkstra(V, adj, S);
cout << "Distance from source to each node: " << endl;
for (int i = 0; i < V; i++)
cout << "0->" << res[i] << " ";
cout << endl;
return 0;
}
OUTPUT:

dijkstra.cpp -o dijkstra } ; if ($?) { .\dijkstra }
21
019
0
Distance from source to each node:
0->0 0->9
Program 23.
Object: Write a program to implement Bellman ford algorithm.
Code:
struct node
{
int u, v, wt;
node(int f, int s, int wait)
{
u = f;
v = s;
wt = wait;
}
};
void bellmanFord()
{
int N, m;
cin >> N >> m;
vector<node> edges;
for (int i = 0; i < m; i++)
{
int u, v, wt;
cin >> u >> v >> wt;
edges.push_back(node(u, v, wt));
}
int src;
cin >> src;
int inf = 1e9;
vector<int> dist(N, inf);
dist[src] = 0;
for (int i = 0; i <= N - 1; i++)
{
{
if (dist[it.u] + it.wt < dist[it.v])
{
dist[it.v] = dist[it.u] + it.wt;
}
}
}
int fl = 0;
{
if (dist[it.u] + it.wt < dist[it.v])
{
cout << "NegativeCycle" << endl;
fl = 1;
break;
}
}
if (!fl)
{
printf("Vertex Distance from Source\n");
for (int i = 0; i < N; ++i)
printf("%d \t\t %d\n", i, dist[i]);
}
}
int main()
{
bellmanFord();
return 0;
}
OUTPUT:
21
019
0
Vertex Distance from Source
0 0
1 9
Program 24.
Object: Write a program to implement Ford Fulkerson algorithm.
Code:
#define V 6
bool bfs(int rGraph[V][V], int s, int t, int parent[])
{
bool visited[V];
memset(visited, 0, sizeof(visited));
queue<int> q;
q.push(s);
visited[s] = true;
parent[s] = -1;
while (!q.empty())
{
int u = q.front();
q.pop();
for (int v = 0; v < V; v++)

{
if (visited[v] == false && rGraph[u][v] > 0)
{
if (v == t)
{
parent[v] = u;
return true;
}
q.push(v);
parent[v] = u;
visited[v] = true;
}
}
}
return false;
}
int fordFulkerson(int graph[V][V], int s, int t)
{
int u, v;
int rGraph[V][V];
for (u = 0; u < V; u++)
for (v = 0; v < V; v++)
rGraph[u][v] = graph[u][v];
int parent[V];
int max_flow = 0; // There is no flow initially
while (bfs(rGraph, s, t, parent))
{
int path_flow = INT_MAX;
for (v = t; v != s; v = parent[v])
{
u = parent[v];
path_flow = min(path_flow, rGraph[u][v]);
}
for (v = t; v != s; v = parent[v])
{
u = parent[v];
rGraph[u][v] -= path_flow;
rGraph[v][u] += path_flow;
}
// Add path flow to overall flow

max_flow += path_flow;
}
// Return the overall flow

return max_flow;
}
int main()
{
int graph[V][V] = {{0, 16, 13, 0, 0, 0}, {0, 0, 10, 12, 0, 0}, {0, 4, 0, 0, 14, 0}, {0, 0, 9, 0, 0, 20}, {0, 0,
0, 7, 0, 4}, {0, 0, 0, 0, 0, 0}};
cout << "The maximum possible flow is "

<< fordFulkerson(graph, 0, 5);
return 0;
}
OUTPUT:
ford.cpp -o ford } ; if ($?) { .\ford }
The maximum possible flow is 23


Daaaa

Uploaded by

Copyright:

Available Formats

Daaaa

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Daaaa

Uploaded by

Copyright:

Available Formats

COLLEGE OF TECHNOLOGY AND ENGINEERING

CLASS :- B.TECH. III YEAR

void countingSort(std::vector<int>& arr) {

// Find the maximum element in the array

// Create a count array to store the count of each element

// Count the occurrences of each element

// Create a temporary array to store the sorted output

// Build the sorted array

CLASS :- B.TECH. III YEAR

// Copy the sorted elements back to the original array

std::cout << "Sorted array:";

CLASS :- B.TECH. III YEAR

PS C:\Users\mukul\OneDrive\Desktop\New folder> cd "c:\Users\mukul\OneDrive\Desktop\New folder\" ; if ($?) {

CLASS :- B.TECH. III YEAR

int getMax(std::vector<int>& arr) {

void countingSort(std::vector<int>& arr, int exp) {

// Store count of occurrences in count[]

for (int i = 1; i < 10; i++) {

CLASS :- B.TECH. III YEAR

// Build the output array

// Copy the output array to arr[], so that arr[] now

void radixSort(std::vector<int>& arr) {

int max = getMax(arr);

CLASS :- B.TECH. III YEAR

std::cout << "Sorted array:";

CLASS :- B.TECH. III YEAR

void bucketSort(std::vector<double>& arr) {

// Put array elements in different buckets

// Sort individual buckets

// Concatenate all buckets into arr[]

CLASS :- B.TECH. III YEAR

std::cout << "Original array:";

std::cout << "Sorted array:";

CLASS :- B.TECH. III YEAR

PS C:\Users\mukul\OneDrive\Desktop\New folder> cd "c:\Users\mukul\OneDrive\Desktop\New folder\"

CLASS :- B.TECH. III YEAR

const int MAX = 1e5;

void lcs(string a, string b, int n, int m) {

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

int index = dp[n][m];

CLASS :- B.TECH. III YEAR

CLASS :- B.TECH. III YEAR

// Function to find the minimum number of scalar multiplications needed

// dp[i][j] will store the minimum number of scalar multiplications

// The result is stored in dp[1][n-1]

CLASS :- B.TECH. III YEAR

CLASS :- B.TECH. III YEAR

// implementation of traveling Salesman Problem

// store minimum weight Hamiltonian Cycle.

// store current Path weight(cost)

// compute current path weight

CLASS :- B.TECH. III YEAR

{15, 35, 0, 30},

PS C:\Users\mukul\OneDrive\Desktop\New folder> cd "c:\Users\mukul\OneDrive\Desktop\New folder\" ; if ($?) { g++

CLASS :- B.TECH. III YEAR

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

CLASS :- B.TECH. III YEAR

cout << "Max Value: " << endl;