Description
Write a class RecentCounter to count recent requests.
It has only one method: ping(int t), where t represents some time in milliseconds.
Return the number of pings that have been made from 3000 milliseconds ago until now.
Any ping with time in [t - 3000, t] will count, including the current ping.
It is guaranteed that every call to ping uses a strictly larger value of t than before.
Example 1:
Input: inputs = [“RecentCounter”,“ping”,“ping”,“ping”,“ping”], inputs = [[],[1],[100],[3001],[3002]]
Output: [null,1,2,3,3]
Note:
Each test case will have at most 10000 calls to ping.
Each test case will call ping with strictly increasing values of t.
Each call to ping will have 1 <= t <= 10^9.
Solution
设计一个RecencCouter类,输入一个带时间戳的ping(),返回最近3000ms内ping的数量。
Using a queue to implement this class. While peek value < t - 3000, poll it out.
Code
class RecentCounter {
private Queue<Integer> queue;
public RecentCounter() {
queue = new LinkedList<Integer>();
}
public int ping(int t) {
queue.offer(t);
while (queue.peek() < t - 3000){
queue.poll();
}
return queue.size();
}
}
/**
* Your RecentCounter object will be instantiated and called as such:
* RecentCounter obj = new RecentCounter();
* int param_1 = obj.ping(t);
*/
Time Complexity: O(N)
Space Complexity: O(Math.min(N, 3000))
Review
Another approach using tree map. TailMap() method will return a map with key bigger than this key.
class RecentCounter {
private TreeMap<Integer, Integer> map;
public RecentCounter() {
map = new TreeMap<Integer, Integer>();
}
public int ping(int t) {
map.put(t, 1 + map.size());
return map.tailMap(t - 3000).size();
}
}
/**
* Your RecentCounter object will be instantiated and called as such:
* RecentCounter obj = new RecentCounter();
* int param_1 = obj.ping(t);
*/
`Time Complexity: O(log N)
Space Complexity: O(N)