LC imp

shreymehul · shreymehul · commit ded322b04682 · 2022-10-28T21:44:20.000+05:30
diff --git a/146.LRUCache.cs b/146.LRUCache.cs
@@ -0,0 +1,169 @@
+// 146. LRU Cache
+
+// Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.
+
+// Implement the LRUCache class:
+
+// LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
+// int get(int key) Return the value of the key if the key exists, otherwise return -1.
+// void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.
+// The functions get and put must each run in O(1) average time complexity.
+
+ 
+
+// Example 1:
+
+// Input
+// ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
+// [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+// Output
+// [null, null, null, 1, null, -1, null, -1, 3, 4]
+
+// Explanation
+// LRUCache lRUCache = new LRUCache(2);
+// lRUCache.put(1, 1); // cache is {1=1}
+// lRUCache.put(2, 2); // cache is {1=1, 2=2}
+// lRUCache.get(1);    // return 1
+// lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
+// lRUCache.get(2);    // returns -1 (not found)
+// lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+// lRUCache.get(1);    // return -1 (not found)
+// lRUCache.get(3);    // return 3
+// lRUCache.get(4);    // return 4
+
+
+//
+public class LRUCache {
+private readonly int _capacity;
+    private readonly Dictionary<int, LinkedListNode<KeyValuePair<int, int>>> _cache;
+    private readonly LinkedList<KeyValuePair<int, int>> _lru;
+
+    public LRUCache(int capacity) 
+    {
+        _capacity = capacity;        
+        _cache = new();
+        _lru = new();
+    }
+    
+    public int Get(int key) 
+    {
+        if (!_cache.TryGetValue(key, out var node))
+        {
+            return -1;
+        }
+        
+        _lru.Remove(node);
+        _cache[key] = _lru.AddFirst(node.Value);
+        
+        return node.Value.Value;        
+    }
+    
+    public void Put(int key, int value) 
+    {
+        if (_cache.TryGetValue(key, out var node))
+        {
+            _lru.Remove(node);
+            _cache.Remove(key);
+        }
+        
+        node = _lru.AddFirst(new KeyValuePair<int, int>(key, value));
+        _cache[key] = node;
+        
+        if (_lru.Count > _capacity)
+        {
+            node = _lru.Last;            
+            _lru.RemoveLast();
+            _cache.Remove(node.Value.Key);            
+        }
+    }
+}
+
+//self defined DLL
+public class LRUCache {
+    public class DoublyLinkList
+    {
+        public (int key, int value) val;
+        public DoublyLinkList prev;
+        public DoublyLinkList next;
+        public DoublyLinkList((int, int) val, DoublyLinkList prev = null,
+                            DoublyLinkList next = null)
+        {
+            this.val = val;
+            this.prev = prev;
+            this.next = next;
+        }
+    }
+    DoublyLinkList root;
+    DoublyLinkList tail;
+    Dictionary<int, DoublyLinkList> cache;
+    int capacity;
+    public LRUCache(int capacity)
+    {
+        cache = new Dictionary<int, DoublyLinkList>();
+        this.capacity = capacity;
+        root = tail = null;
+    }
+
+    public int Get(int key)
+    {
+        if (cache.ContainsKey(key))
+        {
+            Remove(cache[key]);
+            Add(cache[key]);
+            return cache[key].val.value;
+        }
+        return -1;
+    }
+
+    public void Put(int key, int value)
+    {
+        if (cache.ContainsKey(key))
+        {
+            Remove(cache[key]);
+            cache.Remove(key);
+        }
+        DoublyLinkList node = new DoublyLinkList((key, value));
+        Add(node);
+        cache.Add(key, node);
+        if(cache.Count == capacity)
+        {
+            Remove(root);
+            cache.Remove(root.val.key);
+        }
+    }
+    public void Add(DoublyLinkList node)
+    {
+        if (root == null)
+        {
+            root = node;
+            tail = node;
+        }
+        tail.next = node;
+        node.prev = tail;
+        tail = node;
+    }
+    public void Remove(DoublyLinkList node)
+    {
+        if (root == tail)
+            root = tail = null;
+        else if(node == root)
+        {
+            root = root.next;
+            root.prev = null;
+        }
+        else if(node == tail)
+        {
+            tail = tail.prev;
+            tail.next = null;
+        }
+        else
+        {
+            DoublyLinkList Prev = node.prev;
+            DoublyLinkList Next = node.next;
+            if (Prev != null)
+                Prev.next = Next;
+            if (Next != null)
+                Next.prev = Prev;
+        }
+    }
+}
diff --git a/155.MinStack.cs b/155.MinStack.cs
@@ -0,0 +1,73 @@
+// 155. Min Stack
+
+// Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+// Implement the MinStack class:
+
+// MinStack() initializes the stack object.
+// void push(int val) pushes the element val onto the stack.
+// void pop() removes the element on the top of the stack.
+// int top() gets the top element of the stack.
+// int getMin() retrieves the minimum element in the stack.
+// You must implement a solution with O(1) time complexity for each function.
+
+ 
+
+// Example 1:
+
+// Input
+// ["MinStack","push","push","push","getMin","pop","top","getMin"]
+// [[],[-2],[0],[-3],[],[],[],[]]
+
+// Output
+// [null,null,null,null,-3,null,0,-2]
+
+// Explanation
+// MinStack minStack = new MinStack();
+// minStack.push(-2);
+// minStack.push(0);
+// minStack.push(-3);
+// minStack.getMin(); // return -3
+// minStack.pop();
+// minStack.top();    // return 0
+// minStack.getMin(); // return -2
+
+public class MinStack {
+    Stack<(int val,int min)> stack;
+    
+    public MinStack() {
+        stack = new Stack<(int,int)>();
+    }
+    
+    public void Push(int val) {
+        if(stack.Count == 0){
+            stack.Push((val,val));
+        }
+        else{
+            int min = stack.Peek().min;
+            min = Math.Min(min,val);
+            stack.Push((val,min));
+        }
+    }
+    
+    public void Pop() {
+        stack.Pop();
+    }
+    
+    public int Top() {
+        return stack.Peek().val;
+    }
+    
+    public int GetMin() {
+        return stack.Peek().min;
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.Push(val);
+ * obj.Pop();
+ * int param_3 = obj.Top();
+ * int param_4 = obj.GetMin();
+ */
diff --git a/23.MergeKLists.cs b/23.MergeKLists.cs
@@ -0,0 +1,110 @@
+// 23. Merge k Sorted Lists
+
+// You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.
+
+// Merge all the linked-lists into one sorted linked-list and return it.
+
+ 
+
+// Example 1:
+
+// Input: lists = [[1,4,5],[1,3,4],[2,6]]
+// Output: [1,1,2,3,4,4,5,6]
+// Explanation: The linked-lists are:
+// [
+//   1->4->5,
+//   1->3->4,
+//   2->6
+// ]
+// merging them into one sorted list:
+// 1->1->2->3->4->4->5->6
+// Example 2:
+
+// Input: lists = []
+// Output: []
+// Example 3:
+
+// Input: lists = [[]]
+// Output: []
+
+//Approch Divide & Conqure -> Merge Sort
+public class Solution {
+    public ListNode MergeKLists(ListNode[] lists) {
+        if(lists == null || lists.Length == 0)
+            return null;
+        return MergeSort(lists, 0, lists.Length-1);
+    }
+    public ListNode MergeSort(ListNode[] lists, int low, int high){
+        if(low == high)
+            return lists[low];
+        int mid = (high-low)/2 + low;
+        ListNode left = MergeSort(lists, low, mid),
+            right = MergeSort(lists, mid+1, high);
+        return Merge(left, right);
+    }
+    public ListNode Merge(ListNode l1, ListNode l2){
+        ListNode head = new ListNode();
+        ListNode curr = head;
+        
+        while(l1 != null && l2 != null){
+            if(l1.val <= l2.val){
+                curr.next = l1;
+                l1 = l1.next;
+            }
+            else{
+                curr.next = l2;
+                l2 = l2.next;
+            }
+            curr = curr.next;
+        }
+        if(l1 != null){
+            curr.next = l1;
+        }
+        if(l2 != null){
+            curr.next = l2;
+        }
+        return head.next;
+    }
+}
+
+//Approch MinHeap Time O(KLogN) Space O(1)
+public class Solution {
+    public class ListNode
+    {
+        public int val;
+        public ListNode next;
+        public ListNode(int val = 0, ListNode next = null)
+        {
+            this.val = val;
+            this.next = next;
+        }
+    }
+    public ListNode MergeKLists(ListNode[] lists)
+    {
+        PriorityQueue<ListNode> minHeap = new PriorityQueue<ListNode>();
+        ListNode head = null;
+        ListNode current = null;
+        foreach(var item in lists)
+        {
+            minHeap.Add(item);
+        }
+        while (minHeap.Count > 0)
+        {
+            var min = minHeap.Dequeue();
+            var node = new ListNode(min.val);
+            if (head == null)
+            {
+                current = node;
+                head = current;
+            }
+            else
+            {
+                current.next = node;
+            }
+            min = min.next;
+            if (node == null)
+                minHeap.Dequeue(node);
+        }
+        return head;
+    }
+}
