LeetCode 0981. Time Based Key-Value Store Solution in Java, C++, Python & Go | Explanation + Code

Description

Design a time-based key-value data structure that can store multiple values for the same key at different time stamps and retrieve the key's value at a certain timestamp.

Implement the TimeMap class:

• TimeMap() Initializes the object of the data structure.
• void set(String key, String value, int timestamp) Stores the key key with the value value at the given time timestamp.
• String get(String key, int timestamp) Returns a value such that set was called previously, with timestamp_prev <= timestamp. If there are multiple such values, it returns the value associated with the largest timestamp_prev. If there are no values, it returns "".

 

Example 1:

Input
["TimeMap", "set", "get", "get", "set", "get", "get"]
[[], ["foo", "bar", 1], ["foo", 1], ["foo", 3], ["foo", "bar2", 4], ["foo", 4], ["foo", 5]]
Output
[null, null, "bar", "bar", null, "bar2", "bar2"]

Explanation
TimeMap timeMap = new TimeMap();
timeMap.set("foo", "bar", 1);  // store the key "foo" and value "bar" along with timestamp = 1.
timeMap.get("foo", 1);         // return "bar"
timeMap.get("foo", 3);         // return "bar", since there is no value corresponding to foo at timestamp 3 and timestamp 2, then the only value is at timestamp 1 is "bar".
timeMap.set("foo", "bar2", 4); // store the key "foo" and value "bar2" along with timestamp = 4.
timeMap.get("foo", 4);         // return "bar2"
timeMap.get("foo", 5);         // return "bar2"

 

Constraints:

• 1 <= key.length, value.length <= 100
• key and value consist of lowercase English letters and digits.
• 1 <= timestamp <= 107
• All the timestamps timestamp of set are strictly increasing.
• At most 2 * 105 calls will be made to set and get.

Solutions

Solution 1: Hash Table + Ordered Set (or Binary Search)

We can use a hash table kvt to record key-value pairs, where the key is the string key and the value is an ordered set. Each element in the set is a tuple (timestamp, value), representing the value value corresponding to the key key at the timestamp timestamp.

When we need to query the value corresponding to the key key at the timestamp timestamp, we can use the ordered set to find the largest timestamp timestamp' such that timestamp' ≤ timestamp, and then return the corresponding value.

In terms of time complexity, for the set operation, since the insertion operation of the hash table has a time complexity of O(1), the time complexity is O(1). For the get operation, since the lookup operation of the hash table has a time complexity of O(1) and the lookup operation of the ordered set has a time complexity of O(log n), the time complexity is O(log n). The space complexity is O(n), where n is the number of set operations.

PythonJavaC++Go

class TimeMap: def __init__(self): self.ktv = defaultdict(list) def set(self, key: str, value: str, timestamp: int) -> None: self.ktv[key].append((timestamp, value)) def get(self, key: str, timestamp: int) -> str: if key not in self.ktv: return '' tv = self.ktv[key] i = bisect_right(tv, (timestamp, chr(127))) return tv[i - 1][1] if i else '' # Your TimeMap object will be instantiated and called as such: # obj = TimeMap() # obj.set(key,value,timestamp) # param_2 = obj.get(key,timestamp)(code-box)

class TimeMap { private Map<String, TreeMap<Integer, String>> ktv = new HashMap<>(); public TimeMap() { } public void set(String key, String value, int timestamp) { ktv.computeIfAbsent(key, k -> new TreeMap<>()).put(timestamp, value); } public String get(String key, int timestamp) { if (!ktv.containsKey(key)) { return ""; } var tv = ktv.get(key); Integer t = tv.floorKey(timestamp); return t == null ? "" : tv.get(t); } } /** * Your TimeMap object will be instantiated and called as such: * TimeMap obj = new TimeMap(); * obj.set(key,value,timestamp); * String param_2 = obj.get(key,timestamp); */(code-box)

class TimeMap { public: TimeMap() { } void set(string key, string value, int timestamp) { ktv[key].emplace_back(timestamp, value); } string get(string key, int timestamp) { auto& pairs = ktv[key]; pair<int, string> p = {timestamp, string({127})}; auto i = upper_bound(pairs.begin(), pairs.end(), p); return i == pairs.begin() ? "" : (i - 1)->second; } private: unordered_map<string, vector<pair<int, string>>> ktv; }; /** * Your TimeMap object will be instantiated and called as such: * TimeMap* obj = new TimeMap(); * obj->set(key,value,timestamp); * string param_2 = obj->get(key,timestamp); */(code-box)

type TimeMap struct { ktv map[string][]pair } func Constructor() TimeMap { return TimeMap{map[string][]pair{}} } func (this *TimeMap) Set(key string, value string, timestamp int) { this.ktv[key] = append(this.ktv[key], pair{timestamp, value}) } func (this *TimeMap) Get(key string, timestamp int) string { pairs := this.ktv[key] i := sort.Search(len(pairs), func(i int) bool { return pairs[i].t > timestamp }) if i > 0 { return pairs[i-1].v } return "" } type pair struct { t int v string } /** * Your TimeMap object will be instantiated and called as such: * obj := Constructor(); * obj.Set(key,value,timestamp); * param_2 := obj.Get(key,timestamp); */(code-box)