快照数组

难度: Medium

实现支持下列接口的「快照数组」- SnapshotArray：

SnapshotArray(int length) - 初始化一个与指定长度相等的类数组的数据结构。初始时，每个元素都等于 0。
void set(index, val) - 会将指定索引 index 处的元素设置为 val。
int snap() - 获取该数组的快照，并返回快照的编号 snap_id（快照号是调用 snap() 的总次数减去 1）。
int get(index, snap_id) - 根据指定的 snap_id 选择快照，并返回该快照指定索引 index 的值。

示例：

输入：["SnapshotArray","set","snap","set","get"]
     [[3],[0,5],[],[0,6],[0,0]]
输出：[null,null,0,null,5]
解释：
SnapshotArray snapshotArr = new SnapshotArray(3); // 初始化一个长度为 3 的快照数组
snapshotArr.set(0,5);  // 令 array[0] = 5
snapshotArr.snap();  // 获取快照，返回 snap_id = 0
snapshotArr.set(0,6);
snapshotArr.get(0,0);  // 获取 snap_id = 0 的快照中 array[0] 的值，返回 5

提示：

1 <= length <= 50000
题目最多进行50000 次set，snap，和 get的调用。
0 <= index < length
0 <= snap_id < 我们调用 snap() 的总次数
0 <= val <= 10^9

Submission

运行时间: 378 ms

内存: 47.8 MB

from bisect import bisect_left

class SnapshotArray:

    def __init__(self, length: int):
        # 初始化字典数组和 id
        self.arr = [{0: 0} for _ in range(length)]
        self.sid = 0

    def set(self, index: int, val: int) -> None:
        # 设置当前快照的元素值
        self.arr[index][self.sid] = val

    def snap(self) -> int:
        # 每次快照 id 加 1
        self.sid += 1
        # 返回上一个快照 id
        return self.sid - 1

    def get(self, index: int, snap_id: int) -> int:
        # 选择要查找的元素的字典
        d = self.arr[index]
        # 如果快照恰好存在, 直接返回
        if snap_id in d:
            return d[snap_id]
        # 不存在则进行二分搜索, 查找快照前最后一次修改
        k = list(d.keys())
        i = bisect.bisect_left(k, snap_id)
        return d[k[i - 1]]



# Your SnapshotArray object will be instantiated and called as such:
# obj = SnapshotArray(length)
# obj.set(index,val)
# param_2 = obj.snap()
# param_3 = obj.get(index,snap_id)

Explain

这个题解使用了一个字典数组来实现快照数组。每个字典存储了一个索引在不同快照版本中的值。每次调用snap()时，快照id自增，而set()方法则在当前快照id下更新值。get()方法使用二分搜索在当前索引的字典中找到不大于给定快照id的最大快照id，然后返回那个快照id下的值。

时间复杂度: set(): O(1), snap(): O(1), get(): O(logN)

空间复杂度: O(L*N)

from bisect import bisect_left

class SnapshotArray:

    def __init__(self, length: int):
        # 初始化字典数组和快照id
        self.arr = [{0: 0} for _ in range(length)]
        self.sid = 0

    def set(self, index: int, val: int) -> None:
        # 设置当前快照的元素值
        self.arr[index][self.sid] = val

    def snap(self) -> int:
        # 每次快照id加1
        self.sid += 1
        # 返回上一个快照id
        return self.sid - 1

    def get(self, index: int, snap_id: int) -> int:
        # 选择要查找的元素的字典
        d = self.arr[index]
        # 如果快照恰好存在, 直接返回
        if snap_id in d:
            return d[snap_id]
        # 不存在则进行二分搜索, 查找快照前最后一次修改
        k = list(d.keys())
        i = bisect_left(k, snap_id)
        return d[k[i - 1]]

# Your SnapshotArray object will be instantiated and called as such:
# obj = SnapshotArray(length)
# obj.set(index,val)
# param_2 = obj.snap()
# param_3 = obj.get(index,snap_id)

Explore

在`get`方法中，如果直接找到`snap_id`，说明在此快照版本时索引对应的值发生了更改并被记录，因此可以直接返回该值。若`snap_id`未直接找到，意味着在`snap_id`时刻之前的某个版本中最后一次修改了该索引的值，但此后至`snap_id`未再改动过，所以需要通过二分搜索在已有的快照键中找到不超过`snap_id`的最大快照键，以得到正确的数据状态。

在`set`方法中，将值设置在当前快照id下而不是直接修改数组中的值，是为了保留历史数据版本的完整性。这种设计使得系统可以存储和访问某个索引在不同时间点的历史值，支持随时回退到任何之前的快照状态。直接修改数组值将只能保留最新状态，无法实现快照功能。

如果二分搜索的结果是`0`，这表明所有记录的快照键都大于当前查询的`snap_id`。在这种情况下，应返回索引初始状态的值。在快照数组的实现中，每个索引的初始快照（键为0）被设置为0，因此如果`i`为0，则返回索引的初始值，即字典中键为0的值。

在最坏情况下，假设每次`snap()`操作后，每个索引的值都被修改并记录到字典中，这将导致每个索引对应的字典中会记录每次快照时的状态。因此，如果进行了N次`snap()`操作，每个索引的字典最终将包含N个条目，每个条目对应一个快照版本的值。这样，字典中的条目数量与快照次数直接相关，即O(N)。