add 460

fishercoder1534 · fishercoder1534 · commit 4e0bfa062e5c · 2017-06-07T23:03:45.000-07:00
diff --git a/README.md b/README.md
@@ -119,6 +119,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/IslandPerimeter.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/MinimumMovestoEqualArrayElementsII.java) | O(nlogn) |O(1) | Medium|
 |461|[Hamming Distance](https://leetcode.com/problems/hamming-distance/)|[Solution](../master/src/main/java/com/fishercoder/solutions/HammingDistance.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
 |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/PoorPigs.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
diff --git a/src/main/java/com/fishercoder/solutions/LFUCache.java b/src/main/java/com/fishercoder/solutions/LFUCache.java
diff --git a/src/main/java/com/fishercoder/solutions/_460.java b/src/main/java/com/fishercoder/solutions/_460.java
@@ -0,0 +1,66 @@
+package com.fishercoder.solutions;
+
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+
+public class _460 {
+    /**
+     * Wikipedia: The simplest method to employ an LFU algorithm is to assign a counter to every
+     * block that is loaded into the cache. Each time a reference is made to that block the counter
+     * is increased by one. When the cache reaches capacity and has a new block waiting to be
+     * inserted the system will search for the block with the lowest counter and remove it from the
+     * cache.
+     * 
+     * Policy to handle frequency ties: based on timestamp, the entries that get set into cache earlier will be evicted first.
+     */
+    
+    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;
+        int cap;
+        int min = -1;
+        public LFUCache(int capacity) {
+            cap = capacity;
+            vals = new HashMap<>();
+            counts = new HashMap<>();
+            lists = new HashMap<>();
+            lists.put(1, new LinkedHashSet<>());
+        }
+
+        public int get(int key) {
+            if(!vals.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);
+        }
+
+        public void put(int key, int value) {
+            if(cap<=0)
+                return;
+            if(vals.containsKey(key)) {
+                vals.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);
+            }
+            vals.put(key, value);
+            counts.put(key, 1);
+            min = 1;
+            lists.get(1).add(key);
+        }
+    }
+    
+}
