-實現 LFU 緩存算法, 設計一個類 LFUCache，實現下面三個函數
+ 構造函數: 傳入 Cache 內最多能存儲的 key 的數量
+ get(key)：如果 Cache 中存在該 key，則返回對應的 value 值，否則，返回-1。
+ set(key,value)：如果 Cache 中存在該 key，則重置 value 值；如果不存在該 key，則將該 key 插入到到 Cache 中，若插入後會導致 Cache 中存儲的 key 個數超過最大容量，則在插入前淘汰訪問次數最少的數據。

註：
所有 key 和 value 都是 int 類型。
訪問次數：每次get/set一個存在的key都算作對該key的一次訪問；當某個key被淘汰的時候，訪問次數清零。

public class LFUCache{
HashMap<Integer,Integer> keyValues;
HashMap<Integer,Integer> keyCounts;
HashMap<Integer,LinkedHashSet<Integer>> countKeySets;

int capacity;
int min;

public LFUCache(int capacity){
this.capacity = capacity;
this.min = -1;
keyValues = new HashMap<Integer,Integer>();
keyCounts = new HashMap<Integer,Integer>();
countKeySets = new HashMap<Integer,LinkedHashSet<Integer>>;
countKeySets.put(1,LinkedHashSet<Integer>());
}

public int get(int key){
if(!keyValues.containsKey(key)){
return -1;
}
int count = KeyCounts.get(key);
keyCounts.put(key,count+1);
countKeySets.get(count).remove(key);
if(count == min && countKeySets.get(count).size() == 0){
min++;
}
if(!countKeySets.containsKey(count+1){
countKeySets.put(count+1,new LinkedHashSet<Integer>());
}
countKeySets.get(count+1).add(key);
return keyValues.get(key);
}

public void set(int key , int value){
if(capacity <= 0){
return ;
}

if(keyValues.containsKey(key)){
keyValues.put(key,value);
get(key);
return;
}
if(keyValues.size() >= capacity){
int leastFreq = countKeySets.get(min).iterator().next();
keyValues.remove(lestFreq);
keyCounts.remove(lestFreq);
countKeySets.get(min).remove(leastFreq);
}

keyValues.put(key,value);
keyCounts.put(key,1);
countKeySets.get(1).add(key);
min = 1;
}


}

-實現 LFU 緩存算法