[LeetCode 1146] Snapshot Array

mplement a SnapshotArray that supports the following interface:

• SnapshotArray(int length) initializes an array-like data structure with the given length.  Initially, each element equals 0.
• void set(index, val) sets the element at the given index to be equal to val.
• int snap() takes a snapshot of the array and returns the snap_id: the total number of times we called snap() minus 1.
• int get(index, snap_id) returns the value at the given index, at the time we took the snapshot with the given snap_id

Example 1:

Input: ["SnapshotArray","set","snap","set","get"]
[[3],[0,5],[],[0,6],[0,0]]
Output: [null,null,0,null,5]
Explanation: 
SnapshotArray snapshotArr = new SnapshotArray(3); // set the length to be 3
snapshotArr.set(0,5);  // Set array[0] = 5
snapshotArr.snap();  // Take a snapshot, return snap_id = 0
snapshotArr.set(0,6);
snapshotArr.get(0,0);  // Get the value of array[0] with snap_id = 0, return 5

Constraints:

• 1 <= length <= 50000
• At most 50000 calls will be made to set, snap, and get.
• 0 <= index < length
• 0 <= snap_id < (the total number of times we call snap())
• 0 <= val <= 10^9

Each index has its own treemap to store all needed values of different snap ids information. For a key value pair(k, v) in an index's treemap, it means starting from snap id k, until there is a newer snap, the value is v. This representation helps achieve the following properties.

1. O(N) init, O(logS) get and set, where N is the total number of indices and S is the total number of snaps for an index.

2. If there is no value update at index i for consecutive snap shots, there will be only a snap_id to value mapping. When setting a new value at index i, it first check the last entry of its map, this is the latest value prior to this update operation. Only insert a new mapping if the new value is the same with the previous value, which means starting from this new snap id, the value is the new value.  

3. When calling the get method, it tries to find the a key-value mapping associated with the greatest key less than or equal to the given key snap id. 

class SnapshotArray {
    private TreeMap<Integer, Integer>[] snapMap;
    private int snapId = 0;
    public SnapshotArray(int length) {
        snapMap = new TreeMap[length];
        for (int i = 0; i < length; i++) {
            snapMap[i] = new TreeMap<Integer, Integer>();
            snapMap[i].put(0, 0);
        }
    }

    public void set(int index, int val) {
        Map.Entry<Integer, Integer> lastEntry = snapMap[index].lastEntry();
        if(val != lastEntry.getValue()) {
            snapMap[index].put(snapId, val);
        }        
    }

    public int snap() {
        return snapId++;
    }

    public int get(int index, int snap_id) {
        return snapMap[index].floorEntry(snap_id).getValue();
    }
}