---
tags: leetcode
---
# [1146. Snapshot Array](https://leetcode.com/problems/snapshot-array/)
---
# My Solution
## The Key Idea for Solving This Coding Question
## C++ Code
```cpp=
struct valueData {
int value;
int snapId;
valueData(int value, int snapId) : value(value), snapId(snapId) {}
};
class SnapshotArray {
public:
SnapshotArray(int length) : snapId(0), length(length) {}
void set(int index, int val) {
auto iter = array.find(index);
if (iter == array.end()) {
array[index].push_back(valueData(val, snapId));
return;
}
vector<valueData> &valueList = iter->second;
if (valueList.back().snapId == snapId) {
valueList.back().value = val;
return;
}
// valueList.back().snapId < snapId is true.
valueList.push_back(valueData(val, snapId));
}
int snap() {
return snapId++;
}
int get(int index, int snap_id) {
auto iter = array.find(index);
if (iter == array.end()) {
return 0;
}
vector<valueData> &valueList = iter->second;
if (snap_id < valueList[0].snapId) {
return 0;
}
//if (valueList.back().snapId <= snap_id) {
// return valueList.back().value;
//}
// Use binary search to find a snapId that is less than
// or equal to snap_id.
int left = 0, right = valueList.size() - 1;
while (left < right) {
int middle = left + (right - left + 1) / 2;
if (snap_id < valueList[middle].snapId) {
right = middle - 1;
} else {
left = middle;
}
}
if (snap_id < valueList[left].snapId) {
--left;
}
return valueList[left].value;
}
private:
int snapId;
int length;
unordered_map<int, vector<valueData>> array;
};
/**
* Your SnapshotArray object will be instantiated and called as such:
* SnapshotArray* obj = new SnapshotArray(length);
* obj->set(index,val);
* int param_2 = obj->snap();
* int param_3 = obj->get(index,snap_id);
*/
```
## Time Complexity
* `SnapshotArray`
$O(1)$
* `set`
$O(1)$
* `get`
$O(logn)$
$n$ is the maximum number of the values.
## Space Complexity
* `SnapshotArray`
$O(1)$
* `set`
$O(m \cdot n)$
$m$ is the value of `length`, which is the parameter of `SnapshotArray`.
* `get`
$O(1)$
# Miscellaneous
<!--
# Test Cases
```
["SnapshotArray","set","snap","set","get"]
[[3],[0,5],[],[0,6],[0,0]]
```
```
["SnapshotArray","snap","set","set","snap","snap","snap"]
[[2],[],[1,17],[0,20],[],[],[]]
```
```
["SnapshotArray","snap","snap","get","set","snap","set"]
[[4],[],[],[3,1],[2,4],[],[1,4]]
```
```
["SnapshotArray","snap","get","get","set","get","set","get","set"]
[[2],[],[1,0],[0,0],[1,8],[1,0],[0,20],[0,0],[0,7]]
```
```
["SnapshotArray","set","set","snap","get","set","snap","set","set","get","get"]
[[3],[1,18],[1,4],[],[0,0],[0,20],[],[0,2],[1,1],[1,1],[1,0]]
```
```
["SnapshotArray","set","snap","get","set","snap","get","set","snap","get"]
[[50000],[0,25415],[],[0,0],[0,21384],[],[0,1],[0,3754],[],[0,0]]
```
* TLE:
https://leetcode.com/submissions/detail/514324712/
```
["SnapshotArray","set","snap","set","get","snap","get"]
[[3],[0,5],[],[0,6],[0,0],[],[0,1]]
```
```
["SnapshotArray","set","snap","snap","snap","snap","set","snap","snap","set","snap","snap","set","get"]
[[2],[1,8],[],[],[],[],[1,10],[],[],[1,19],[],[],[1,99],[1,5]]
```
-->