add implementations for smallest range in k sorted lists and LRU cache

Author: Adityasinghvats

24binarytree/03elementsAtNthLevel.exe

@@ -0,0 +1,44 @@
+#include<bits/stdc++.h>
+/*
+for k lists each of size n
+TC = O(nk log k)
+*/
+using namespace std;
+typedef pair<int, pair<int,int>> pp;
+    //{element ,{row, col}}
+    vector<int> smallestRange(vector<vector<int>>& nums) {
+        priority_queue<pp, vector<pp> , greater<pp>> pq;
+        int k = nums.size();//to make sure heap doesnot have more than 1 ele from each subarray
+        int mx = INT_MIN;
+        for(int i=0; i<nums.size(); i++){
+            mx = max(mx, nums[i][0]);
+            pq.push({nums[i][0], {i, 0}});
+        }
+        int min = pq.top().first;
+        int start = min; 
+        int end = mx;
+        while(true){
+            int top_ele_row = pq.top().second.first;
+            int top_ele_col = pq.top().second.second;
+            pq.pop();
+            if(top_ele_col == nums[top_ele_row].size()-1) break; //reaches end of a row
+            int newele = nums[top_ele_row][top_ele_col+1];
+            pq.push({newele, {top_ele_row,top_ele_col+1}});
+            mx = max(mx, newele);
+            min = pq.top().first;
+            //comapre with previous range ans see if it is new range is less , replace start and end
+            if(mx-min < end-start){
+                end = mx;
+                start = min;
+            }
+        }
+        return {start, end};
+    }
+int main(){
+    vector<vector<int>> v = {{4,10,15,24,26},{0,9,12,20},{5,18,22,30}};
+    vector<int> ans = smallestRange(v);
+    for(int ele:ans){
+        cout<<ele<<" ";
+    }
+    return 0;
+}

26Heap/LC632.cpp

@@ -0,0 +1,90 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+struct Node{
+    string val;
+    Node* left = nullptr;
+    Node* right = nullptr;
+};
+struct Queue{
+    Node* head = nullptr;
+    Node* tail = nullptr;
+    int length;
+    void display(){
+        Node* n = head->right;
+        cout<<"[";
+        while(n!= tail){
+            cout<<n->val<<" -> ";
+            n = n->right;
+        }
+        cout<<"]"<<"\n\n";
+    }
+};
+typedef unordered_map<string, Node*> Hash;
+
+struct Cache{
+    Queue q;
+    Hash h;
+    void check(string word){
+       //find word in map if it is there remove it and insert at front of queue
+       if(h.find(word) != h.end()){
+        //get the node from hash
+        Node* n = h[word];
+        remove(n);
+        //add code
+        add(n);
+       }else{
+        Node* n = new Node({word});
+        add(n);
+       }  
+    }
+    void add(Node* n){
+        string word = n->val;
+        cout<<"Inserting `"<<word<<"` to lru cache"<<endl;
+        n->right = q.head->right;
+        n->left = q.head;
+        q.head->right = n;
+        n->right->left = n;
+        q.length++;
+        h.insert({word, n});
+        if(q.length > 5){
+            cout<<"Cache full removing last element !!!"<<endl;
+            remove(q.tail->left);
+        }
+    }
+    Node* remove(Node* n){
+        Node* l = n->left;
+        Node* r = n->right;
+        //remove
+        l->right = r;
+        r->left = l;
+        q.length--;
+        h.erase(n->val);
+        return n;
+    }
+    void display(){
+        q.display();
+    }
+};
+Queue newQueue(){
+    Node* head = new Node();
+    Node* tail = new Node();
+    tail->left = head;
+    head->right = tail;
+    return Queue({head, tail, 0});
+}
+Cache newCache(){
+    Queue q = newQueue();
+    Hash h;
+    return Cache({q, h});
+}
+
+int main(){
+    Cache cache = newCache();
+    vector<string> v = {"parrot", "avocado", "tree", "potato", "tomato", "tree", "man", "monkey", "deer", "man"};
+    for(string s: v){
+        cache.check(s);
+        cache.display();
+    }
+    return 0;
+}