时间复杂度：TextEditor O(1) addText O(|text|) deleteText O(k) cursorLeft O(k) cursorRight(k)
空间复杂度：O(n)

由于每个字符需要创建一个节点（17+个字节），虽然没有超时，但实际工程中是不能使用这种方式的。

// https://zxi.mytechroad.com/blog/string/leetcode-2296-design-a-text-editor/
class TextEditor {
public:
  TextEditor(): data_{'$'}, cursor_{begin(data_)} {}
  
  void addText(string text) {
    for (char c : text)
      cursor_ = data_.insert(++cursor_, c);
  }
  
  int deleteText(int k) {
    for (int i = 0; i < k; ++i) {
      if (cursor_ == begin(data_)) return i;
      data_.erase(cursor_--);
    }
    return k;
  }
  
  string cursorLeft(int k) {
    for (int i = 0; i < k; ++i) {
      if (cursor_ == begin(data_)) break;
      cursor_--;
    }
    return getText();
  }
  
  string cursorRight(int k) {
    for (int i = 0; i < k; ++i) {
      if (cursor_ == prev(end(data_))) break;
      cursor_++;
    }
    return getText();
  }
private:
  string getText() {
    string ans;
    auto it = cursor_;
    for (int i = 0; i < 10; ++i) {
      if (it == begin(data_)) break;
      ans += *it--;
    }
    reverse(begin(ans), end(ans));
    return ans;
  }

  list<char> data_;
  list<char>::iterator cursor_;
};

方法2: 用两个string来代表光标左边的字符串和光标右边的字符串。注：右边字符串是反转的。

左右两边的字符串只会增长（或者覆盖），不会缩短，这是用空间换时间。

删除的时候就是修改了长度而已，并没有缩短字符串，所以是O(1)的。
如果缩短的话需则要O(k)时间，还要加上内存释放/再分配的时间，应该会慢一些但不多。

移动光标的时候，就是把左边字符串的最后k个copy到右边的最后面，或者反过来。同样没有缩短，只会变长。

时间复杂度: TextEditor O(1) addText O(|text|) deleteText O(1) cursorLeft O(k) cursorRight(k)
空间复杂度：O(n)，n为构建的最长的字符串

// https://zxi.mytechroad.com/blog/string/leetcode-2296-design-a-text-editor/
class TextEditor {
public:
  TextEditor() {}
  
  void addText(string_view text) {
    ensureSize(l, m + text.size());
    copy(begin(text), end(text), begin(l) + m);
    m += text.size();
  }
  
  int deleteText(int k) {
    k = min(k, m);
    m -= k;
    return k;
  }
  
  string cursorLeft(int k) {
    ensureSize(r, n + k);
    for (k = min(k, m); k > 0; --k)
      r[n++] = l[--m];
    return getText();
  }
  
  string cursorRight(int k) {
    ensureSize(l, m + k);
    for (k = min(k, n); k > 0; --k)
      l[m++] = r[--n];
    return getText();
  }
private:
  inline void ensureSize(string& s, int size) {
    if (s.size() < size)
      s.resize(size);
  }

  string getText() const {
    return string(begin(l) + m - min(m, 10), begin(l) + m);
  }

  string l;
  string r;
  int m = 0;
  int n = 0;
};

用了三个Hashtable…

1. 菜名 -> 菜系
2. 菜系 -> Treemap
3. 菜名 -> 所在Treemap中的迭代器

每个菜系用一个TreeSet来保存从高到低的菜色排名，查询的时候只要拿出第一个就好了。

修改的时候，拿出迭代器，删除原来的评分，再把新的评分加入（别忘了更新迭代器）

时间复杂度：构造O(nlogn)，修改O(logn)，查询O(1)

空间复杂度：O(n)

class FoodRatings {
public:
  FoodRatings(vector<string>& foods, vector<string>& cuisines, vector<int>& ratings) {
    const int n = foods.size();
    for (int i = 0; i < n; ++i) {
      n_[foods[i]] = cuisines[i];
      m_[foods[i]] = c_[cuisines[i]].emplace(-ratings[i], foods[i]).first;
    }
  }
  
  void changeRating(string food, int newRating) {
    const string& cuisine = n_[food];
    c_[cuisine].erase(m_[food]);
    m_[food] = c_[cuisine].emplace(-newRating, food).first;
  }
  
  string highestRated(string cuisine) {
    return begin(c_[cuisine])->second;
  }
private:
  unordered_map<string, set<pair<int, string>>> c_; // cuisine -> {{-rating, name}}
  unordered_map<string, string> n_; // food -> cuisine  
  unordered_map<string, set<pair<int, string>>::iterator> m_; // food -> set iterator
};

/**
 * Your FoodRatings object will be instantiated and called as such:
 * FoodRatings* obj = new FoodRatings(foods, cuisines, ratings);
 * obj->changeRating(food,newRating);
 * string param_2 = obj->highestRated(cuisine);
 */

所有操作都是O(logn)

class TaskManager {
public:
    TaskManager(vector<vector<int>>& tasks) {
      for (const auto& task : tasks)
        add(task[0], task[1], task[2]);
    }

    void add(int userId, int taskId, int priority) {
      m_[taskId] = pq_.emplace(make_pair(priority, taskId), userId).first;
    }
    
    void edit(int taskId, int newPriority) {
      const int userId = m_[taskId]->second;
      rmv(taskId);
      add(userId, taskId, newPriority);
    }
    
    void rmv(int taskId) {
      auto it = m_.find(taskId);
      pq_.erase(it->second);
      m_.erase(it);
    }
    
    int execTop() {
      if (pq_.empty()) return -1;
      auto it = pq_.rbegin();
      const int userId = it->second;
      const int taskId = (it->first.second);
      rmv(taskId);
      return userId;
    }
  private:
    map<std::pair<int,int>, int> pq_; // (priority, taskId) -> userId;
    unordered_map<int, map<std::pair<int,int>, int>::iterator> m_; // taskId -> pq iterator
};

You are building a system that tracks the ranking of locations with the system initially starting with no locations. It supports:

• Adding scenic locations, one at a time.
• Querying the ith best location of all locations already added, where i is the number of times the system has been queried (including the current query).
  • For example, when the system is queried for the 4th time, it returns the 4th best location of all locations already added.

Note that the test data are generated so that at any time, the number of queries does not exceed the number of locations added to the system.

Implement the SORTracker class:

• SORTracker() Initializes the tracker system.
• void add(string name, int score) Adds a scenic location with name and score to the system.
• string get() Queries and returns the ith best location, where i is the number of times this method has been invoked (including this invocation).

Example 1:

<strong>Input</strong>
["SORTracker", "add", "add", "get", "add", "get", "add", "get", "add", "get", "add", "get", "get"]
[[], ["bradford", 2], ["branford", 3], [], ["alps", 2], [], ["orland", 2], [], ["orlando", 3], [], ["alpine", 2], [], []]
<strong>Output</strong>
[null, null, null, "branford", null, "alps", null, "bradford", null, "bradford", null, "bradford", "orland"]
<p><strong>Explanation</strong> 
SORTracker tracker = new SORTracker(); // Initialize the tracker system.
tracker.add("bradford", 2);            // Add location with name="bradford" and score=2 to the system.
tracker.add("branford", 3);            // Add location with name="branford" and score=3 to the system.
tracker.get();                         // The sorted locations, from best to worst, are: branford, bradford. 
                                       // Note that branford precedes bradford due to its <strong>higher score</strong> (3 &gt; 2). 
                                       // This is the 1<sup>st</sup> time get() is called, so return the best location: "branford". 
tracker.add("alps", 2);                // Add location with name="alps" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, alps, bradford. 
                                       // Note that alps precedes bradford even though they have the same score (2). 
                                       // This is because "alps" is <strong>lexicographically smaller</strong> than "bradford". 
                                       // Return the 2<sup>nd</sup> best location "alps", as it is the 2<sup>nd</sup> time get() is called.
tracker.add("orland", 2);              // Add location with name="orland" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, alps, bradford, orland. 
                                       // Return "bradford", as it is the 3<sup>rd</sup> time get() is called. 
tracker.add("orlando", 3);             // Add location with name="orlando" and score=3 to the system.
tracker.get();                         // Sorted locations: branford, orlando, alps, bradford, orland. 
                                       // Return "bradford". 
tracker.add("alpine", 2);              // Add location with name="alpine" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
                                       // Return "bradford". 
tracker.get();                         // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
                                       // Return "orland".
</p>

Constraints:

• name consists of lowercase English letters, and is unique among all locations.
• 1 <= name.length <= 10
• 1 <= score <= 105
• At any time, the number of calls to get does not exceed the number of calls to add.
• At most 4 * 104 calls in total will be made to add and get.

Solution: TreeSet w/ Iterator

Use a treeset to store all the entries and use a iterator that points to the entry to return. When inserting a new entry into the tree, if it’s higher than the current element then let the iterator go backward one step.

Time complexity: add O(logn) / get O(1)

// Author: Huahua
class SORTracker {
public:
  SORTracker() {}

  void add(string name, int score) {    
    if (*s.emplace(-score, name).first < *cit) --cit;
  }

  string get() {
    return (cit++)->second;
  }
private:
  set<pair<int, string>> s;
  // Note: cit points to begin(s) after first insertion.
  set<pair<int, string>>::const_iterator cit = end(s);
};

Implement the FrontMiddleBack class:

• FrontMiddleBack() Initializes the queue.
• void pushFront(int val) Adds val to the front of the queue.
• void pushMiddle(int val) Adds val to the middle of the queue.
• void pushBack(int val) Adds val to the back of the queue.
• int popFront() Removes the front element of the queue and returns it. If the queue is empty, return -1.
• int popMiddle() Removes the middle element of the queue and returns it. If the queue is empty, return -1.
• int popBack() Removes the back element of the queue and returns it. If the queue is empty, return -1.

Notice that when there are two middle position choices, the operation is performed on the frontmost middle position choice. For example:

• Pushing 6 into the middle of [1, 2, 3, 4, 5] results in [1, 2, 6, 3, 4, 5].
• Popping the middle from [1, 2, 3, 4, 5, 6] returns 3 and results in [1, 2, 4, 5, 6].

Example 1:

Input:
["FrontMiddleBackQueue", "pushFront", "pushBack", "pushMiddle", "pushMiddle", "popFront", "popMiddle", "popMiddle", "popBack", "popFront"]
[[], [1], [2], [3], [4], [], [], [], [], []]
Output:
[null, null, null, null, null, 1, 3, 4, 2, -1]
Explanation:
FrontMiddleBackQueue q = new FrontMiddleBackQueue();
q.pushFront(1);   // [1]
q.pushBack(2);    // [1, 2]
q.pushMiddle(3);  // [1, 3, 2]
q.pushMiddle(4);  // [1, 4, 3, 2]
q.popFront();     // return 1 -> [4, 3, 2]
q.popMiddle();    // return 3 -> [4, 2]
q.popMiddle();    // return 4 -> [2]
q.popBack();      // return 2 -> []
q.popFront();     // return -1 -> [] (The queue is empty)

Constraints:

• 1 <= val <= 109
• At most 1000 calls will be made to pushFront, pushMiddle, pushBack, popFront, popMiddle, and popBack.

Solution: List + Middle Iterator

Time complexity: O(1) per op
Space complexity: O(n) in total

// Author: Huahua
class FrontMiddleBackQueue {
public:
  FrontMiddleBackQueue() {}

  void pushFront(int val) {
    q_.push_front(val); 
    updateMit(even() ? -1 : 0);
  }

  void pushMiddle(int val) {    
    if (q_.empty())
      q_.push_back(val);
    else
      q_.insert(even() ? next(mit_) : mit_, val);
    updateMit(even() ? -1 : 1);
  }

  void pushBack(int val) {    
    q_.push_back(val); 
    updateMit(even() ? 0 : 1);
  }

  int popFront() {     
    if (q_.empty()) return -1;
    int val = q_.front();
    q_.pop_front();
    updateMit(even() ? 0 : 1);
    return val;
  }

  int popMiddle() {    
    if (q_.empty()) return -1;
    int val = *mit_;
    mit_ = q_.erase(mit_);
    updateMit(even() ? -1 : 0);
    return val;
  }

  int popBack() {    
    if (q_.empty()) return -1;
    int val = q_.back();
    q_.pop_back();
    updateMit(even() ? -1 : 0);
    return val;
  }
private:  
  void updateMit(int delta) {
    if (q_.size() <= 1) {      
      mit_ = begin(q_);
    } else {
      if (delta > 0) ++mit_;
      if (delta < 0) --mit_;
    }    
  }
  
  bool even() const { return q_.size() % 2 == 0; }
  
  list<int> q_;
  list<int>::iterator mit_;
};

Example Code:

# Author: Huahua
class MyListIterator:
  def __init__(self, my_list, index=0):
    self.my_list = my_list
    self.index = index

  def __next__(self):
    if self.index < len(self.my_list.data):
      val = self.my_list.data[self.index]
      self.index += 1
      return val
    else:
      raise StopIteration()

  def __iter__(self):
    return MyListIterator(self.my_list, self.index)
    # return self

class MyList:
  def __init__(self, data):
    self.data = list(data)

  def __getitem__(self, index):
    return self.data[index]

  def __len__(self):
    return len(self.data)

  def __iter__(self):
    return MyListIterator(self)

my_list = MyList([1,2,3,4,5])
it = iter(my_list)
next(it)
it2 = iter(it)
next(it)
print('--- it ---')
for x in it:
  print(x) # 3, 4, 5
print('--- it2 ---')
for x in it2:
  print(x) # 2, 3, 4, 5