From 4f3729aa3fcfa9e4dda144b2c84be4943f668304 Mon Sep 17 00:00:00 2001 From: apoorvsingh500 <52244299+apoorvsingh500@users.noreply.github.com> Date: Sat, 12 Oct 2019 11:52:39 +0530 Subject: [PATCH] Add files via upload --- Greedy/greedy algo1.cpp | 36 +++++++ Greedy/huffman's algo.cpp | 106 +++++++++++++++++++++ Greedy/krushkal's algo.cpp | 190 +++++++++++++++++++++++++++++++++++++ Greedy/prim's algo.cpp | 107 +++++++++++++++++++++ 4 files changed, 439 insertions(+) create mode 100644 Greedy/greedy algo1.cpp create mode 100644 Greedy/huffman's algo.cpp create mode 100644 Greedy/krushkal's algo.cpp create mode 100644 Greedy/prim's algo.cpp diff --git a/Greedy/greedy algo1.cpp b/Greedy/greedy algo1.cpp new file mode 100644 index 00000000..86fb5c29 --- /dev/null +++ b/Greedy/greedy algo1.cpp @@ -0,0 +1,36 @@ +// C++ program to find minimum number of denominations +#include +using namespace std; + +// All denominations of Indian Currency +int deno[] = { 1, 2, 5, 10, 20, 50, 100, 500, 1000 }; +int n = sizeof(deno) / sizeof(deno[0]); + +// Driver program +void findMin(int V) +{ + // Initialize result + vector ans; + + // Traverse through all denomination + for (int i = n - 1; i >= 0; i--) { + // Find denominations + while (V >= deno[i]) { + V -= deno[i]; + ans.push_back(deno[i]); + } + } + + // Print result + for (int i = 0; i < ans.size(); i++) + cout << ans[i] << " "; +} + +// Driver program +int main() +{ + int n = 93; + cout << "Following is minimal number of change for " << n << " is "; + findMin(n); + return 0; +} \ No newline at end of file diff --git a/Greedy/huffman's algo.cpp b/Greedy/huffman's algo.cpp new file mode 100644 index 00000000..b00b33ab --- /dev/null +++ b/Greedy/huffman's algo.cpp @@ -0,0 +1,106 @@ + +// A Huffman tree node +struct MinHeapNode { + + // One of the input characters + char data; + + // Frequency of the character + unsigned freq; + + // Left and right child + MinHeapNode *left, *right; + + MinHeapNode(char data, unsigned freq) + + { + + left = right = NULL; + this->data = data; + this->freq = freq; + } +}; + +// For comparison of +// two heap nodes (needed in min heap) +struct compare { + + bool operator()(MinHeapNode* l, MinHeapNode* r) + + { + return (l->freq > r->freq); + } +}; + +// Prints huffman codes from +// the root of Huffman Tree. +void printCodes(struct MinHeapNode* root, string str) +{ + + if (!root) + return; + + if (root->data != '$') + cout << root->data << ": " << str << "\n"; + + printCodes(root->left, str + "0"); + printCodes(root->right, str + "1"); +} + +// The main function that builds a Huffman Tree and +// print codes by traversing the built Huffman Tree +void HuffmanCodes(char data[], int freq[], int size) +{ + struct MinHeapNode *left, *right, *top; + + // Create a min heap & inserts all characters of data[] + priority_queue, compare> minHeap; + + for (int i = 0; i < size; ++i) + minHeap.push(new MinHeapNode(data[i], freq[i])); + + // Iterate while size of heap doesn't become 1 + while (minHeap.size() != 1) { + + // Extract the two minimum + // freq items from min heap + left = minHeap.top(); + minHeap.pop(); + + right = minHeap.top(); + minHeap.pop(); + + // Create a new internal node with + // frequency equal to the sum of the + // two nodes frequencies. Make the + // two extracted node as left and right children + // of this new node. Add this node + // to the min heap '$' is a special value + // for internal nodes, not used + top = new MinHeapNode('$', left->freq + right->freq); + + top->left = left; + top->right = right; + + minHeap.push(top); + } + + // Print Huffman codes using + // the Huffman tree built above + printCodes(minHeap.top(), ""); +} + +// Driver program to test above functions +int main() +{ + + char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; + int freq[] = { 5, 9, 12, 13, 16, 45 }; + + int size = sizeof(arr) / sizeof(arr[0]); + + HuffmanCodes(arr, freq, size); + + return 0; +} + \ No newline at end of file diff --git a/Greedy/krushkal's algo.cpp b/Greedy/krushkal's algo.cpp new file mode 100644 index 00000000..45b66fdb --- /dev/null +++ b/Greedy/krushkal's algo.cpp @@ -0,0 +1,190 @@ +// C++ program for Kruskal's algorithm to find Minimum Spanning Tree +// of a given connected, undirected and weighted graph +#include +using namespace std; + +// a structure to represent a weighted edge in graph +class Edge +{ + public: + int src, dest, weight; +}; + +// a structure to represent a connected, undirected +// and weighted graph +class Graph +{ + public: + // V-> Number of vertices, E-> Number of edges + int V, E; + + // graph is represented as an array of edges. + // Since the graph is undirected, the edge + // from src to dest is also edge from dest + // to src. Both are counted as 1 edge here. + Edge* edge; +}; + +// Creates a graph with V vertices and E edges +Graph* createGraph(int V, int E) +{ + Graph* graph = new Graph; + graph->V = V; + graph->E = E; + + graph->edge = new Edge[E]; + + return graph; +} + +// A structure to represent a subset for union-find +class subset +{ + public: + int parent; + int rank; +}; + +// A utility function to find set of an element i +// (uses path compression technique) +int find(subset subsets[], int i) +{ + // find root and make root as parent of i + // (path compression) + if (subsets[i].parent != i) + subsets[i].parent = find(subsets, subsets[i].parent); + + return subsets[i].parent; +} + +// A function that does union of two sets of x and y +// (uses union by rank) +void Union(subset subsets[], int x, int y) +{ + int xroot = find(subsets, x); + int yroot = find(subsets, y); + + // Attach smaller rank tree under root of high + // rank tree (Union by Rank) + if (subsets[xroot].rank < subsets[yroot].rank) + subsets[xroot].parent = yroot; + else if (subsets[xroot].rank > subsets[yroot].rank) + subsets[yroot].parent = xroot; + + // If ranks are same, then make one as root and + // increment its rank by one + else + { + subsets[yroot].parent = xroot; + subsets[xroot].rank++; + } +} + +// Compare two edges according to their weights. +// Used in qsort() for sorting an array of edges +int myComp(const void* a, const void* b) +{ + Edge* a1 = (Edge*)a; + Edge* b1 = (Edge*)b; + return a1->weight > b1->weight; +} + +// The main function to construct MST using Kruskal's algorithm +void KruskalMST(Graph* graph) +{ + int V = graph->V; + Edge result[V]; // Tnis will store the resultant MST + int e = 0; // An index variable, used for result[] + int i = 0; // An index variable, used for sorted edges + + // Step 1: Sort all the edges in non-decreasing + // order of their weight. If we are not allowed to + // change the given graph, we can create a copy of + // array of edges + qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp); + + // Allocate memory for creating V ssubsets + subset *subsets = new subset[( V * sizeof(subset) )]; + + // Create V subsets with single elements + for (int v = 0; v < V; ++v) + { + subsets[v].parent = v; + subsets[v].rank = 0; + } + + // Number of edges to be taken is equal to V-1 + while (e < V - 1 && i < graph->E) + { + // Step 2: Pick the smallest edge. And increment + // the index for next iteration + Edge next_edge = graph->edge[i++]; + + int x = find(subsets, next_edge.src); + int y = find(subsets, next_edge.dest); + + // If including this edge does't cause cycle, + // include it in result and increment the index + // of result for next edge + if (x != y) + { + result[e++] = next_edge; + Union(subsets, x, y); + } + // Else discard the next_edge + } + + // print the contents of result[] to display the + // built MST + cout<<"Following are the edges in the constructed MST\n"; + for (i = 0; i < e; ++i) + cout<edge[0].src = 0; + graph->edge[0].dest = 1; + graph->edge[0].weight = 10; + + // add edge 0-2 + graph->edge[1].src = 0; + graph->edge[1].dest = 2; + graph->edge[1].weight = 6; + + // add edge 0-3 + graph->edge[2].src = 0; + graph->edge[2].dest = 3; + graph->edge[2].weight = 5; + + // add edge 1-3 + graph->edge[3].src = 1; + graph->edge[3].dest = 3; + graph->edge[3].weight = 15; + + // add edge 2-3 + graph->edge[4].src = 2; + graph->edge[4].dest = 3; + graph->edge[4].weight = 4; + + KruskalMST(graph); + + return 0; +} + \ No newline at end of file diff --git a/Greedy/prim's algo.cpp b/Greedy/prim's algo.cpp new file mode 100644 index 00000000..7f409b8f --- /dev/null +++ b/Greedy/prim's algo.cpp @@ -0,0 +1,107 @@ +// STL implementation of Prim's algorithm for MST +#include +using namespace std; +# define INF 0x3f3f3f3f + +// iPair ==> Integer Pair +typedef pair iPair; + +// To add an edge +void addEdge(vector > adj[], int u, + int v, int wt) +{ + adj[u].push_back(make_pair(v, wt)); + adj[v].push_back(make_pair(u, wt)); +} + +// Prints shortest paths from src to all other vertices +void primMST(vector > adj[], int V) +{ + // Create a priority queue to store vertices that + // are being preinMST. This is weird syntax in C++. + // Refer below link for details of this syntax + // http://geeksquiz.com/implement-min-heap-using-stl/ + priority_queue< iPair, vector , greater > pq; + + int src = 0; // Taking vertex 0 as source + + // Create a vector for keys and initialize all + // keys as infinite (INF) + vector key(V, INF); + + // To store parent array which in turn store MST + vector parent(V, -1); + + // To keep track of vertices included in MST + vector inMST(V, false); + + // Insert source itself in priority queue and initialize + // its key as 0. + pq.push(make_pair(0, src)); + key[src] = 0; + + /* Looping till priority queue becomes empty */ + while (!pq.empty()) + { + // The first vertex in pair is the minimum key + // vertex, extract it from priority queue. + // vertex label is stored in second of pair (it + // has to be done this way to keep the vertices + // sorted key (key must be first item + // in pair) + int u = pq.top().second; + pq.pop(); + + inMST[u] = true; // Include vertex in MST + + // Traverse all adjacent of u + for (auto x : adj[u]) + { + // Get vertex label and weight of current adjacent + // of u. + int v = x.first; + int weight = x.second; + + // If v is not in MST and weight of (u,v) is smaller + // than current key of v + if (inMST[v] == false && key[v] > weight) + { + // Updating key of v + key[v] = weight; + pq.push(make_pair(key[v], v)); + parent[v] = u; + } + } + } + + // Print edges of MST using parent array + for (int i = 1; i < V; ++i) + printf("%d - %d\n", parent[i], i); +} + +// Driver program to test methods of graph class +int main() +{ + int V = 9; + vector adj[V]; + + // making above shown graph + addEdge(adj, 0, 1, 4); + addEdge(adj, 0, 7, 8); + addEdge(adj, 1, 2, 8); + addEdge(adj, 1, 7, 11); + addEdge(adj, 2, 3, 7); + addEdge(adj, 2, 8, 2); + addEdge(adj, 2, 5, 4); + addEdge(adj, 3, 4, 9); + addEdge(adj, 3, 5, 14); + addEdge(adj, 4, 5, 10); + addEdge(adj, 5, 6, 2); + addEdge(adj, 6, 7, 1); + addEdge(adj, 6, 8, 6); + addEdge(adj, 7, 8, 7); + + primMST(adj, V); + + return 0; +} \ No newline at end of file