Merge branch 'acesdit:main' into main

Author: AnkurSalunkhe11

ALGORITHMS/Constrained Subsequence Sum.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int constrainedSubsetSum(vector<int>& v, int k) {
+        int n=v.size();
+        vector<int>dp(n,0);
+        priority_queue<pair<int,int>>pq;
+        pq.push({v[0],0});
+        dp[0]=v[0];
+        int ans=v[0];
+        for(int i=1;i<n;i++){
+            while(!pq.empty()){
+                auto p=pq.top();
+                if(i-p.second>k){
+                    pq.pop();
+                }
+                else{
+                    break;
+                }
+            }
+            dp[i]=max(v[i],v[i]+pq.top().first);
+            ans=max(ans,dp[i]);
+            pq.push({dp[i],i});
+        }
+        return ans;
+    }
+};

README.md

@@ -171,6 +171,13 @@ We are open to new additions and suggestions. Contribute by adding more snippets
             <br />
             <sub><b>Vardhaman619</b></sub>
         </a>
+    </td>
+    <td align="center">
+        <a href="https://github.com/nikhil730">
+            <img src="https://avatars.githubusercontent.com/u/79016958?v=4" width="100;" alt="nikhil730"/>
+            <br />
+            <sub><b>nikhil730</b></sub>
+        </a>
     </td></tr>
 </table>
 <!-- readme: collaborators,contributors -end -->

src/pages/submissions/Constrained Subsequence Sum.cpp.md

@@ -0,0 +1,35 @@
+---
+extension: cpp
+author: nikhil730
+category: Algorithms
+layout: '../../layouts/SubmissionLayout.astro'
+title: Constrained Subsequence Sum
+---
+```cpp
+class Solution {
+public:
+    int constrainedSubsetSum(vector<int>& v, int k) {
+        int n=v.size();
+        vector<int>dp(n,0);
+        priority_queue<pair<int,int>>pq;
+        pq.push({v[0],0});
+        dp[0]=v[0];
+        int ans=v[0];
+        for(int i=1;i<n;i++){
+            while(!pq.empty()){
+                auto p=pq.top();
+                if(i-p.second>k){
+                    pq.pop();
+                }
+                else{
+                    break;
+                }
+            }
+            dp[i]=max(v[i],v[i]+pq.top().first);
+            ans=max(ans,dp[i]);
+            pq.push({dp[i],i});
+        }
+        return ans;
+    }
+};
+```

src/pages/submissions/Huffman Compression Algorithm.cpp.md

@@ -0,0 +1,182 @@
+---
+extension: cpp
+author: AnkurSalunkhe11
+category: Algorithms
+layout: '../../layouts/SubmissionLayout.astro'
+title: Huffman Compression Algorithm
+---
+```cpp
+#include <iostream>
+#include <string>
+#include <queue>
+#include <unordered_map>
+using namespace std;
+ 
+#define EMPTY_STRING ""
+ 
+// A Tree node
+struct Node
+{
+    char ch;
+    int freq;
+    Node *left, *right;
+};
+ 
+// Function to allocate a new tree node
+Node* getNode(char ch, int freq, Node* left, Node* right)
+{
+    Node* node = new Node();
+ 
+    node->ch = ch;
+    node->freq = freq;
+    node->left = left;
+    node->right = right;
+ 
+    return node;
+}
+ 
+// Comparison object to be used to order the heap
+struct comp
+{
+    bool operator()(const Node* l, const Node* r) const
+    {
+        // the highest priority item has the lowest frequency
+        return l->freq > r->freq;
+    }
+};
+ 
+// Utility function to check if Huffman Tree contains only a single node
+bool isLeaf(Node* root) {
+    return root->left == nullptr && root->right == nullptr;
+}
+ 
+// Traverse the Huffman Tree and store Huffman Codes in a map.
+void encode(Node* root, string str, unordered_map<char, string> &huffmanCode)
+{
+    if (root == nullptr) {
+        return;
+    }
+ 
+    // found a leaf node
+    if (isLeaf(root)) {
+        huffmanCode[root->ch] = (str != EMPTY_STRING) ? str : "1";
+    }
+ 
+    encode(root->left, str + "0", huffmanCode);
+    encode(root->right, str + "1", huffmanCode);
+}
+ 
+// Traverse the Huffman Tree and decode the encoded string
+void decode(Node* root, int &index, string str)
+{
+    if (root == nullptr) {
+        return;
+    }
+ 
+    // found a leaf node
+    if (isLeaf(root))
+    {
+        cout << root->ch;
+        return;
+    }
+ 
+    index++;
+ 
+    if (str[index] == '0') {
+        decode(root->left, index, str);
+    }
+    else {
+        decode(root->right, index, str);
+    }
+}
+ 
+// Builds Huffman Tree and decodes the given input text
+void buildHuffmanTree(string text)
+{
+    // base case: empty string
+    if (text == EMPTY_STRING) {
+        return;
+    }
+ 
+    // count the frequency of appearance of each character
+    // and store it in a map
+    unordered_map<char, int> freq;
+    for (char ch: text) {
+        freq[ch]++;
+    }
+ 
+    // Create a priority queue to store live nodes of the Huffman tree
+    priority_queue<Node*, vector<Node*>, comp> pq;
+ 
+    // Create a leaf node for each character and add it
+    // to the priority queue.
+    for (auto pair: freq) {
+        pq.push(getNode(pair.first, pair.second, nullptr, nullptr));
+    }
+ 
+    // do till there is more than one node in the queue
+    while (pq.size() != 1)
+    {
+        // Remove the two nodes of the highest priority
+        // (the lowest frequency) from the queue
+ 
+        Node* left = pq.top(); pq.pop();
+        Node* right = pq.top();    pq.pop();
+ 
+        // create a new internal node with these two nodes as children and
+        // with a frequency equal to the sum of the two nodes' frequencies.
+        // Add the new node to the priority queue.
+ 
+        int sum = left->freq + right->freq;
+        pq.push(getNode('\0', sum, left, right));
+    }
+ 
+    // `root` stores pointer to the root of Huffman Tree
+    Node* root = pq.top();
+ 
+    // Traverse the Huffman Tree and store Huffman Codes
+    // in a map. Also, print them
+    unordered_map<char, string> huffmanCode;
+    encode(root, EMPTY_STRING, huffmanCode);
+ 
+    cout << "Huffman Codes are:\n" << endl;
+    for (auto pair: huffmanCode) {
+        cout << pair.first << " " << pair.second << endl;
+    }
+ 
+    cout << "\nThe original string is:\n" << text << endl;
+ 
+    // Print encoded string
+    string str;
+    for (char ch: text) {
+        str += huffmanCode[ch];
+    }
+ 
+    cout << "\nThe encoded string is:\n" << str << endl;
+    cout << "\nThe decoded string is:\n";
+ 
+    if (isLeaf(root))
+    {
+        // Special case: For input like a, aa, aaa, etc.
+        while (root->freq--) {
+            cout << root->ch;
+        }
+    }
+    else {
+        // Traverse the Huffman Tree again and this time,
+        // decode the encoded string
+        int index = -1;
+        while (index < (int)str.size() - 1) {
+            decode(root, index, str);
+        }
+    }
+}
+ 
+// Huffman coding algorithm implementation in C++
+int main()
+{
+    string text = "Huffman coding is a data compression algorithm.";
+    buildHuffmanTree(text);
+ 
+    return 0;
+}```