lfu cache: 90% done

Author: rampatra

src/main/java/com/leetcode/design/LFUCache.java

@@ -0,0 +1,127 @@
+package com.leetcode.design;
+
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Level: Hard
+ * Link: https://leetcode.com/problems/lfu-cache/
+ * Description:
+ * Design and implement a data structure for Least Frequently Used (LFU) cache. It should support the following
+ * operations: get and put.
+ *
+ * get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
+ * put(key, value) - Set or insert the value if the key is not already present. When the cache reaches its capacity, it
+ * should invalidate the least frequently used item before inserting a new item. For the purpose of this problem, when
+ * there is a tie (i.e., two or more keys that have the same frequency), the least recently used key would be evicted.
+ *
+ * Follow up:
+ * Could you do both operations in O(1) time complexity?
+ *
+ * Note:
+ * -
+ *
+ * @author rampatra
+ * @since 2019-08-20
+ */
+public class LFUCache {
+
+    private int minCount = 0;
+    private int capacity;
+    private Map<Integer, Integer> keyValueMap;
+    private Map<Integer, Integer> keyCountMap;
+    private Map<Integer, LinkedHashSet<Integer>> countKeysMap;
+
+
+    public LFUCache(int capacity) {
+        this.capacity = capacity;
+        keyValueMap = new HashMap<>();
+        keyCountMap = new HashMap<>();
+        countKeysMap = new HashMap<>();
+    }
+
+
+    public int get(int key) {
+        Integer val = keyValueMap.get(key);
+        if (val == null) {
+            return -1;
+        }
+
+        int prevCount = keyCountMap.get(key);
+        countKeysMap.getOrDefault(prevCount, new LinkedHashSet<>()).remove(key);
+        countKeysMap.putIfAbsent(prevCount + 1, new LinkedHashSet<>());
+        countKeysMap.get(prevCount + 1).add(key);
+
+        if (prevCount == minCount && countKeysMap.get(prevCount).size() == 0) {
+            minCount++;
+        }
+
+        return val;
+    }
+
+
+    public void put(int key, int value) {
+        if (capacity <= 0) {
+            return;
+        }
+
+        if (!keyValueMap.containsKey(key) && keyCountMap.size() == capacity) {
+            int keyToEvict = countKeysMap.get(minCount).iterator().next();
+            countKeysMap.get(minCount).remove(keyToEvict);
+            keyValueMap.remove(keyToEvict);
+            keyCountMap.remove(keyToEvict);
+        }
+
+        keyValueMap.put(key, value);
+        int prevCount = keyCountMap.getOrDefault(key, 0);
+        keyCountMap.put(key, 1);
+
+        countKeysMap.getOrDefault(prevCount, new LinkedHashSet<>()).remove(key);
+        countKeysMap.putIfAbsent(1, new LinkedHashSet<>());
+        countKeysMap.get(1).add(key);
+
+        minCount = 1;
+    }
+
+
+    public static void main(String[] args) {
+        LFUCache lfuCache = new LFUCache(2);
+        lfuCache.put(2, 2);
+        lfuCache.put(3, 3);
+        lfuCache.put(4, 4);
+        assertEquals(-1, lfuCache.get(2));
+        assertEquals(3, lfuCache.get(3));
+        lfuCache.put(5, 5);
+        assertEquals(-1, lfuCache.get(4));
+
+        lfuCache = new LFUCache(2);
+        lfuCache.put(3, 1);
+        lfuCache.put(2, 1);
+        lfuCache.put(2, 2);
+        lfuCache.put(4, 4);
+        assertEquals(-1, lfuCache.get(3));
+        assertEquals(2, lfuCache.get(2));
+
+        lfuCache = new LFUCache(2);
+        lfuCache.put(2, 1);
+        lfuCache.put(2, 2);
+        assertEquals(2, lfuCache.get(2));
+        lfuCache.put(1, 1);
+        lfuCache.put(4, 4);
+        assertEquals(2, lfuCache.get(2));
+
+        lfuCache = new LFUCache(2);
+        assertEquals(-1, lfuCache.get(2));
+        lfuCache.put(2, 6);
+        assertEquals(-1, lfuCache.get(1));
+        lfuCache.put(1, 1);
+        lfuCache.put(1, 2);
+        assertEquals(2, lfuCache.get(1));
+        assertEquals(6, lfuCache.get(2));
+
+        // todo fix some test cases https://leetcode.com/submissions/detail/253376947/
+    }
+}

src/main/java/com/rampatra/linkedlists/LRUCache.java

@@ -2,6 +2,7 @@
 
 import java.util.Iterator;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
 
 /**
@@ -20,7 +21,7 @@
  */
 public class LRUCache<E, V> {
 
-    LinkedHashMap<E, V> linkedHashMap;
+    private LinkedHashMap<E, V> linkedHashMap;
 
     // initialize cache
     LRUCache(final int size) {
@@ -37,7 +38,7 @@ V add(E key, V value) {
     }
 
     V get(E key) {
-       return linkedHashMap.get(key);
+        return linkedHashMap.get(key);
     }
 
     private void print() {
@@ -52,12 +53,13 @@ public static void main(String[] args) {
         cache.add(1, 1);
         cache.add(2, 2);
         cache.add(3, 3);
+        cache.print(); // initial cache contents
+
+        cache.add(4, 4); // should remove 1 as it was accessed last
         cache.print();
-        if (cache.get(4) == null) {
-            cache.add(4, 4);
-        }
-        cache.print();
-        cache.add(5, 5);
+
+        cache.get(2);
+        cache.add(5, 5); // should remove 3 as 2 was recently accessed
         cache.print();
     }
 }