edit 460

Author: fishercoder1534

README.md

@@ -163,7 +163,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |463|[Island Perimeter](https://leetcode.com/problems/island-perimeter/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_463.java)| O(m*n)|O(1) | Easy| 
 |462|[Minimum Moves to Equal Array Elements II](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_462.java) | O(nlogn) |O(1) | Medium|
 |461|[Hamming Distance](https://leetcode.com/problems/hamming-distance/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_461.java) | O(n) |O(1) | Easy|
-|460|[LFU Cache](https://leetcode.com/problems/lfu-cache/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_460.java) | O(?) |O(?) | Hard| Design
+|460|[LFU Cache](https://leetcode.com/problems/lfu-cache/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_460.java) | O(1) |O(n) | Hard| Design, LinkedHashMap, HashMap
 |459|[Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_459.java)| O(n)|O(n) | Easy| KMP
 |458|[Poor Pigs](https://leetcode.com/problems/poor-pigs/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_458.java) | O(1) |O(1) | Easy| Math
 |456|[132 Pattern](https://leetcode.com/problems/132-pattern/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_456.java) | O(n) |O(n) | Medium| Stack

src/main/java/com/fishercoder/solutions/_460.java

@@ -3,6 +3,36 @@
 import java.util.HashMap;
 import java.util.LinkedHashSet;
 
+/**460. LFU Cache
+ * 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?
+
+ Example:
+
+ LFUCache cache = new LFUCache( 2 /* capacity  );
+
+        cache.put(1, 1);
+        cache.put(2, 2);
+        cache.get(1);       // returns 1
+        cache.put(3, 3);    // evicts key 2
+        cache.get(2);       // returns -1 (not found)
+        cache.get(3);       // returns 3.
+        cache.put(4, 4);    // evicts key 1.
+        cache.get(1);       // returns -1 (not found)
+        cache.get(3);       // returns 3
+        cache.get(4);       // returns 4
+
+ */
+
 public class _460 {
     /**
      * Wikipedia: The simplest method to employ an LFU algorithm is to assign a counter to every
@@ -14,53 +44,75 @@ public class _460 {
      * Policy to handle frequency ties: based on timestamp, the entries that get set into cache earlier will be evicted first.
      */
 
-    class LFUCache {
+    public static class LFUCache {
         /**credit: https://discuss.leetcode.com/topic/69737/java-o-1-very-easy-solution-using-3-hashmaps-and-linkedhashset/2*/
-        HashMap<Integer, Integer> vals;
-        HashMap<Integer, Integer> counts;
-        HashMap<Integer, LinkedHashSet<Integer>> lists;
+
+        HashMap<Integer, Integer> keyToValue;/**key is the key, value is the value*/
+        HashMap<Integer, Integer> keyToCount;/**key is the key, value if the count of the key/value pair*/
+        HashMap<Integer, LinkedHashSet<Integer>> countToLRUKeys;
+        /**key is count, value is a set of keys that have the same key, but keeps insertion order*/
         int cap;
-        int min = -1;
+        int minimumCount;
+
         public LFUCache(int capacity) {
-            cap = capacity;
-            vals = new HashMap<>();
-            counts = new HashMap<>();
-            lists = new HashMap<>();
-            lists.put(1, new LinkedHashSet<>());
+            this.minimumCount = -1;
+            this.cap = capacity;
+            this.keyToValue = new HashMap<>();
+            this.keyToCount = new HashMap<>();
+            this.countToLRUKeys = new HashMap<>();
+            this.countToLRUKeys.put(1, new LinkedHashSet<>());
         }
 
         public int get(int key) {
-            if(!vals.containsKey(key))
+            if (!keyToValue.containsKey(key)) {
                 return -1;
-            int count = counts.get(key);
-            counts.put(key, count+1);
-            lists.get(count).remove(key);
-            if(count==min && lists.get(count).size()==0)
-                min++;
-            if(!lists.containsKey(count+1))
-                lists.put(count+1, new LinkedHashSet<>());
-            lists.get(count+1).add(key);
-            return vals.get(key);
+            }
+            int count = keyToCount.get(key);
+            keyToCount.put(key, count + 1);
+            countToLRUKeys.get(count).remove(key);
+
+            if (count == minimumCount && countToLRUKeys.get(count).size() == 0) {
+                /**This means this key's count equals to current minimumCount
+                 * AND
+                 * this count doesn't have any entries in the cache.
+                 * So, we'll increment minimumCount by 1 to get the next LFU cache entry
+                 * when we need to evict.*/
+                minimumCount++;
+            }
+
+            if (!countToLRUKeys.containsKey(count + 1)) {
+                countToLRUKeys.put(count + 1, new LinkedHashSet<>());
+            }
+            countToLRUKeys.get(count + 1).add(key);
+
+            return keyToValue.get(key);
         }
 
         public void put(int key, int value) {
-            if(cap<=0)
+            if (cap <= 0) {
                 return;
-            if(vals.containsKey(key)) {
-                vals.put(key, value);
+            }
+
+            if (keyToValue.containsKey(key)) {
+                /**If the key is already in the cache, we can simply overwrite this entry;
+                 * then call get(key) which will do the update work.*/
+                keyToValue.put(key, value);
                 get(key);
                 return;
             }
-            if(vals.size() >= cap) {
-                int evit = lists.get(min).iterator().next();
-                lists.get(min).remove(evit);
-                vals.remove(evit);
+
+            /**If the key is not in the cache, we'll check the size first, evict the LFU entry first,
+             * then insert this one into cache.*/
+            if (keyToValue.size() >= cap) {
+                int evit = countToLRUKeys.get(minimumCount).iterator().next();
+                countToLRUKeys.get(minimumCount).remove(evit);
+                keyToValue.remove(evit);
             }
-            vals.put(key, value);
-            counts.put(key, 1);
-            min = 1;
-            lists.get(1).add(key);
+            keyToValue.put(key, value);
+            keyToCount.put(key, 1);
+            countToLRUKeys.get(1).add(key);/**Because we put this key/value into cache for the first time, so its count is 1*/
+            minimumCount = 1;/**For the same above reason, minimumCount is of course 1*/
         }
     }
-    
+
 }

src/test/java/com/fishercoder/_460Test.java

@@ -0,0 +1,26 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._460;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _460Test {
+
+    private static _460.LFUCache lfuCache;
+
+    @Test
+    public void test1(){
+        lfuCache = new _460.LFUCache(2);
+        lfuCache.put(1, 1);
+        lfuCache.put(2, 2);
+        assertEquals(1, lfuCache.get(1));
+        lfuCache.put(3, 3);
+        assertEquals(-1, lfuCache.get(2));
+        assertEquals(3, lfuCache.get(3));
+        lfuCache.put(4, 4);
+        assertEquals(-1, lfuCache.get(1));
+        assertEquals(3, lfuCache.get(3));
+        assertEquals(4, lfuCache.get(4));
+    }
+}