leetcode 1851 离散化考虑事件 堆降维 离线处理

此题用到了离线处理，即不将请求当做在线操作，对请求做预处理后再搞。

解法一：multiset+离散化
这个题的难点在于，要把开始，结束，以及查询全部转化为事件，左端点加入时，长度加入multiset，右端点加入时，排出对应的长度。需要查询时，看最小长度即可。和1854题类似。

typedef tuple<int, int, int> T; //位置，长度，类型
class Solution {
public:
    vector<int> minInterval(vector<vector<int>>& intervals, vector<int>& queries) {
        vector<T> v;
        multiset<int> m;
        for(auto i: intervals)
        {
            v.emplace_back(i[0], -1, i[1]-i[0]+1);
            v.emplace_back(i[1], 1, i[1]-i[0]+1);
        }

        for(int i=0;i<queries.size();i++)
        {
            v.emplace_back(queries[i], 0, i);
        }
        sort(v.begin(), v.end());

        vector<int> ret(queries.size());
        for(auto t: v)
        {
            int type = get<1>(t), len = get<2>(t);
            if(type == 0)
            {
                if(m.empty())ret[len] = -1;
                else ret[len] = *m.begin();
            }
            else if(type == -1)
            {
                m.insert(len);
            }
            else
            {
                m.erase(m.find(len));
            }
        }

        return ret;
    }
};

解法二：堆
将请求从小到大排列，区间x排序。每次堆（按长度排序）放入左端点满足条件的，排出后若右端点也满足就ok，不然一直排。这样一直处理。
这样做的道理是，如果满足不了小的query，右端点肯定也满足不了大的。这个太强了，直接降维打击。。爱了。

typedef pair<int, int> P;
class Solution {
public:
    vector<int> minInterval(vector<vector<int>>& intervals, vector<int>& queries) {
        // 构建query
        vector<P> ques;
        for(int i=0;i<queries.size();i++)
        {
            ques.emplace_back(queries[i], i);
        }
        sort(ques.begin(), ques.end());

        // 区间排序
        sort(intervals.begin(), intervals.end());

        // 处理
        priority_queue<P> q;
        vector<int> ret(queries.size(), -1);
        int j = 0;
        for(auto que: ques)
        {
            // 左端点满足的放入堆中
            while(j < intervals.size() && intervals[j][0] <= que.first)
            {
                int len = intervals[j][1] - intervals[j][0] + 1;
                q.push(P(-len, intervals[j][1]));
                j++;
            }

            // 排出
            while(!q.empty())
            {
                if(q.top().second >= que.first)
                {
                    ret[que.second] = -q.top().first;
                    break;
                }
                q.pop();
            }
        }

        return ret;
    }
};