146. LRU Cache && 460. LFU Cache

146. LRU Cache

Design and implement a data structure for Least Recently Used (LRU) 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 reached its capacity, it should invalidate the least recently used item before inserting a new item.

Follow up:
Could you do both operations in O(1) time complexity?

Example:

LRUCache cache = new LRUCache( 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.put(4, 4);    // evicts key 1
cache.get(1);       // returns -1 (not found)
cache.get(3);       // returns 3
cache.get(4);       // returns 4

Solution:

Cache all nodes in a DoubleLinkedList. Always pop out from the left, and add from the right.

Use a map to map key to a node.

class LRUCache {
  private int capacity;
  private int count = 0;
  private Map<Integer, CacheNode> cacheMap = new HashMap<>();

  private CacheNode LEFT = new CacheNode(0, 0);
  private CacheNode RIGHT = new CacheNode(0, 0);

  public LRUCache(int capacity) {
    this.capacity = capacity;
    LEFT.right = RIGHT;
    RIGHT.left = LEFT;
  }

  public int get(int key) {
    CacheNode node = cacheMap.get(key);
    if (node == null) {
      return -1;
    } else {
      removeNode(node);
      addNewNode(node);
      return node.value;
    }
  }

  public void put(int key, int value) {
    if (capacity == 0)
      return;

    CacheNode orig = cacheMap.get(key);
    CacheNode n = new CacheNode(key, value);
    addNewNode(n); //add new node to the right
    cacheMap.put(key, n);

    if (orig != null) {
      removeNode(orig); //remove original node.
      return;
    }

    //if capacity is not full
    if (count < capacity) {
      ++count;
      return;
    }

    CacheNode evict = LEFT.right;
    cacheMap.remove(evict.key);
    removeNode(evict); //removeNode last node.
  }

  private void removeNode(CacheNode node) {
    CacheNode pre = node.left;
    CacheNode next = node.right;
    pre.right = next;
    next.left = pre;
  }

  //Add a new node, add it to the end/Right
  private void addNewNode(CacheNode node) {
    node.left = RIGHT.left;
    node.right = RIGHT;
    RIGHT.left.right = node;
    RIGHT.left = node;
  }
}

class CacheNode {
  CacheNode left = null;
  CacheNode right = null;
  int key = 0;
  int value = 0;

  CacheNode(int key, int value) {
    this.key = key;
    this.value = value;
  }
}

 

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


This is just an extension of LRU. LFU is just a map of LRU keyed by the frequency!

/**
 * !!! Note that both get and put will increase frequency by 1  !!!
 */
class LFUCache {
  private int _capacity;
  private int _count = 0;
  //To capture the minimum frequency count in the LFU cache
  //Alternatively, we can link all LRU cache together.
  private int _leastCount = 0;
  private Map<Integer, LRUCache> frequencyMap = new HashMap<>();
  private Map<Integer, CacheNode> keyMap = new HashMap<>();

  public LFUCache(int capacity) {
    _capacity = capacity;
  }

  public int get(int key) {
    CacheNode node = keyMap.get(key);
    if (node == null) {
      return -1;
    }
    increaseFreq(node);
    return node.value;
  }

  //remove node from current level and move it to the next level
  private void increaseFreq(CacheNode node) {
    LRUCache currentCache = frequencyMap.get(node.count);
    currentCache.removeNode(node);
    if (node.count == _leastCount && currentCache.isEmpty()) {
      ++_leastCount; //we are moving this node to next level
    }

    ++node.count;
    LRUCache nextCache = frequencyMap.computeIfAbsent(node.count, (x) -> new LRUCache());
    nextCache.addNewNode(node);
  }

  public void put(int key, int value) {
    CacheNode node = keyMap.get(key);
    if (node != null) {
      node.value = value;
      increaseFreq(node);
      return;
    }

    LRUCache zeroFreqCache = frequencyMap.computeIfAbsent(0, (x) -> new LRUCache());
    CacheNode newNode = new CacheNode(key, value, 0);
    zeroFreqCache.addNewNode(newNode);
    keyMap.put(key, newNode);
    if (_count < _capacity) {
      ++_count;
    } else {
      LRUCache cacheToEvict = frequencyMap.get(_leastCount);
      CacheNode nodeToEvict = cacheToEvict.LEFT.right;
      keyMap.remove(nodeToEvict.key);
      cacheToEvict.removeNode(nodeToEvict);
    }
    _leastCount = 0;
  }
}

class LRUCache {
  public final CacheNode LEFT = new CacheNode(0, 0, 0);
  public final CacheNode RIGHT = new CacheNode(0, 0, 0);

  public LRUCache() {
    LEFT.right = RIGHT;
    RIGHT.left = LEFT;
  }

  public void removeNode(CacheNode node) {
    CacheNode pre = node.left;
    CacheNode next = node.right;
    pre.right = next;
    next.left = pre;
  }

  public void addNewNode(CacheNode node) {
    node.left = RIGHT.left;
    node.right = RIGHT;
    RIGHT.left.right = node;
    RIGHT.left = node;
  }

  public boolean isEmpty() {
    return LEFT.right == RIGHT;
  }
}

class CacheNode {
  CacheNode left = null;
  CacheNode right = null;
  int key;
  int value;
  int count;

  CacheNode(int key, int value, int count) {
    this.key = key;
    this.value = value;
    this.count = count;
  }
}