732. My Calendar III

Implement a MyCalendarThree class to store your events. A new event can always be added.

Your class will have one method, book(int start, int end). Formally, this represents a booking on the half open interval [start, end), the range of real numbers x such that start <= x < end.

A K-booking happens when K events have some non-empty intersection (ie., there is some time that is common to all K events.)

For each call to the method MyCalendar.book, return an integer K representing the largest integer such that there exists a K-booking in the calendar.

Your class will be called like this: MyCalendarThree cal = new MyCalendarThree(); MyCalendarThree.book(start, end)

Example 1:
MyCalendarThree();
MyCalendarThree.book(10, 20); // returns 1
MyCalendarThree.book(50, 60); // returns 1
MyCalendarThree.book(10, 40); // returns 2
MyCalendarThree.book(5, 15); // returns 3
MyCalendarThree.book(5, 10); // returns 3
MyCalendarThree.book(25, 55); // returns 3

这一题一开始还是希望像之前的两题一样，只用一个无序的vector< pair< int, int>> 来遍历，一个数组存起始和终止的时间点组合，一个数组存对应的重复频率。每一次新的book都遍历是否有重复，有的话将重复部分，非重复部分都重新存入，始终保持每一个time slot都是separate的。这样可行，但是写起来很麻烦。

简洁做法：
构建一个map, map是一个有序的，key-value组合，每一个key都是unique的。内部实现是binary search tree。By the way, unordered_map内部是hash table.
代码如下：
每一次开始在对应时间+1，每一个结束都是-1，如果还没结束就开始了另一个+1，那就说明重复了一次。
基本原理如下，最后按照时间顺序找到某一个重复次数最多的时刻即可。

class MyCalendarThree {
private:
    map<int, int> mymap;
public:
    MyCalendarThree() {
    }

    int book(int start, int end) {
        mymap[start]++;
        mymap[end]--;
        int res = 0;
        int cur = 0;
        for (auto e : mymap) {
            cur += e.second;
            res = max(res, cur);
        }
        return res;
    }
};

map and set:
map::insert

#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  // first insert function version (single parameter):
  mymap.insert ( std::pair<char,int>('a',100) );
  mymap.insert ( std::pair<char,int>('z',200) );

  std::pair<std::map<char,int>::iterator,bool> ret;
  ret = mymap.insert ( std::pair<char,int>('z',500) );
  if (ret.second==false) {
    std::cout << "element 'z' already existed";
    std::cout << " with a value of " << ret.first->second << '\n';
  }

  // second insert function version (with hint position):
  std::map<char,int>::iterator it = mymap.begin();
  mymap.insert (it, std::pair<char,int>('b',300));  // max efficiency inserting
  mymap.insert (it, std::pair<char,int>('c',400));  // no max efficiency inserting

  // third insert function version (range insertion):
  std::map<char,int> anothermap;
  anothermap.insert(mymap.begin(),mymap.find('c'));

  return 0;
}

这里值得注意的是，insert的返回值是一个pair 类型，如果想要判断插入是否成功以及获得插入的位置，可以用上述那种构造一个对应的pair. 或者用auto res = mymap.insert({a, 100}). res.first 就是一个指向插入位置的迭代器，res.second 就是一个true or false. 如果是false 代表插入失败，然后first是already exist的位置。
这里也可以用tie(a, b)来做。tie一般用来unpack pair 或者 tuple之类的数据。实现定义好a and b, 然后可以用tie 将返回值分别赋值给a and b。

map::erase

it=mymap.find('b');
mymap.erase (it);                   // erasing by iterator
mymap.erase ('c');                  // erasing by key
it=mymap.find ('e');
mymap.erase ( it, mymap.end() );    // erasing by range

如果想要建立可以重复的key下的map，就要用multimap。
multimap的insert和erase用法与map几乎一致，对于重复元素，如果erase by iterator, 只删一个，如果erase by key, 都删了。find的时候，有多个，返回第一个的iterator。
对于重复问题的两个常用成员函数。count和equal_range.

// 统计key为"Jack"的数目  
    std::string strFind = "Jack";  
    unsigned int uCount = myMultiMap.count(strFind);  
    if (uCount == 0)  
    {  
        std::cout << "================Count " << strFind << ":0"<< std::endl;  
    }  
    else  
    {  
        std::cout << "================Count " << strFind << ":" << uCount << std::endl;  
        std::multimap<std::string, int>::iterator iter = myMultiMap.find(strFind);  
        if (iter != myMultiMap.end())  
        {  
            for (unsigned int i = 0; i < uCount; ++i)  
            {  
                std::cout << (*iter).first << ":" << (*iter).second << std::endl;  
                iter++;  
            }  
        }  
    }  


    std::cout << "================use equal_range"<< std::endl;  
    typedef std::multimap<std::string, int>::iterator MultiMapIterator;  
    std::pair<MultiMapIterator, MultiMapIterator> iterPair = myMultiMap.equal_range("Jack");  
    for (MultiMapIterator it = iterPair.first; it != iterPair.second; ++it)  
    {  
        std::cout << (*it).first << ":" << (*it).second << std::endl;  
    }  

equal_range 返回的是一个pair组合。两个元素分别是起始的iterator。

set 和multiset几乎是类似的设置。
都是基于平衡二叉树。只不过不是key-value的配置，只有key。