[LeetCode] 2034. Stock Price Fluctuation

You are given a stream of records about a particular stock. Each record contains a timestamp and the corresponding price of the stock at that timestamp.

Unfortunately due to the volatile nature of the stock market, the records do not come in order. Even worse, some records may be incorrect. Another record with the same timestamp may appear later in the stream correcting the price of the previous wrong record.

Design an algorithm that:

• Updates the price of the stock at a particular timestamp, correcting the price from any previous records at the timestamp.
• Finds the latest price of the stock based on the current records. The latest price is the price at the latest timestamp recorded.
• Finds the maximum price the stock has been based on the current records.
• Finds the minimum price the stock has been based on the current records.

Implement the StockPrice class:

• StockPrice() Initializes the object with no price records.
• void update(int timestamp, int price) Updates the price of the stock at the given timestamp.
• int current() Returns the latest price of the stock.
• int maximum() Returns the maximum price of the stock.
• int minimum() Returns the minimum price of the stock.

Example 1:

Input
["StockPrice", "update", "update", "current", "maximum", "update", "maximum", "update", "minimum"]
[[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
Output
[null, null, null, 5, 10, null, 5, null, 2]

Explanation
StockPrice stockPrice = new StockPrice();
stockPrice.update(1, 10); // Timestamps are [1] with corresponding prices [10].
stockPrice.update(2, 5);  // Timestamps are [1,2] with corresponding prices [10,5].
stockPrice.current();     // return 5, the latest timestamp is 2 with the price being 5.
stockPrice.maximum();     // return 10, the maximum price is 10 at timestamp 1.
stockPrice.update(1, 3);  // The previous timestamp 1 had the wrong price, so it is updated to 3.
                          // Timestamps are [1,2] with corresponding prices [3,5].
stockPrice.maximum();     // return 5, the maximum price is 5 after the correction.
stockPrice.update(4, 2);  // Timestamps are [1,2,4] with corresponding prices [3,5,2].
stockPrice.minimum();     // return 2, the minimum price is 2 at timestamp 4.

Constraints:

• 1 <= timestamp, price <= 109
• At most 105 calls will be made in total to update, current, maximum, and minimum.
• current, maximum, and minimum will be called only after update has been called at least once.

股票价格波动。

给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。

不巧的是，由于股票市场内在的波动性，股票价格记录可能不是按时间顺序到来的。某些情况下，有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中，前一条记录视为错误记录，后出现的记录 更正 前一条错误的记录。

请你设计一个算法，实现：

更新 股票在某一时间戳的股票价格，如果有之前同一时间戳的价格，这一操作将 更正 之前的错误价格。
找到当前记录里 最新股票价格 。最新股票价格 定义为时间戳最晚的股票价格。
找到当前记录里股票的 最高价格 。
找到当前记录里股票的 最低价格 。
请你实现 StockPrice 类：

StockPrice() 初始化对象，当前无股票价格记录。
void update(int timestamp, int price) 在时间点 timestamp 更新股票价格为 price 。
int current() 返回股票 最新价格 。
int maximum() 返回股票 最高价格 。
int minimum() 返回股票 最低价格 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/stock-price-fluctuation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这是一道设计题。题意不难懂，我直接讲思路。

这道题我们需要两个treemap，records 记录<时间戳，价格>，vals <价格，这个价格涉及到的所有时间戳>。尤其第二个 treemap 比较巧妙，这里他记录的是同一个价格，一共出现过几次。

注意题目要求实现的几个函数，

• update() 很好理解，找到一个之前的 timestamp 并更新价格。但是注意我们需要把错误的价格 prevPrice 从第二个 treemap 里删除，并且如果这个价格只出现过一次的话，要把这个价格从 vals 里删除。
• current() - 因为 records 作为一个 treemap，他的 key 是有序的，所以我们直接返回最后一个 key 背后对应的 value即可，这就是当前的股价
• maximum() - 因为 vals 是 treemap，所以返回 vals 里最后一个key
• minimum() - 因为 vals 是 treemap，所以返回 vals 里第一个key

时间O(nlogn) - treemap的读取操作是O(1)，但是内部的排序需要O(nlogn)

空间O(n)

Java实现

class StockPrice {
    TreeMap<Integer, Integer> records;      // <timestamp, price>
    TreeMap<Integer, Set<Integer>> vals;    // <price, set of timestamp>

    public StockPrice() {
        records = new TreeMap<>();
        vals = new TreeMap<>();
    }
    
    public void update(int timestamp, int price) {
        if (records.containsKey(timestamp)) {
            int prevPrice = records.get(timestamp);
            Set<Integer> set = vals.get(prevPrice);
            set.remove(timestamp);
            if (set.size() == 0) {
                vals.remove(prevPrice);
            }
        }
        records.put(timestamp, price);
        vals.putIfAbsent(price, new HashSet<>());
        vals.get(price).add(timestamp);
    }
    
    public int current() {
        return records.lastEntry().getValue();
    }
    
    public int maximum() {
        return vals.lastKey();
    }
    
    public int minimum() {
        return vals.firstKey();
    }
}

/**
 * Your StockPrice object will be instantiated and called as such:
 * StockPrice obj = new StockPrice();
 * obj.update(timestamp,price);
 * int param_2 = obj.current();
 * int param_3 = obj.maximum();
 * int param_4 = obj.minimum();
 */

相关题目

981. Time Based Key-Value Store

2034. Stock Price Fluctuation

LeetCode 题目总结