标签：return cur int res c++ intervals vector 扫描线 leetcode

#include <iostream>
#include <vector>
#include <unordered_map>
#include <queue>
#include <algorithm>

using namespace std;

bool cmp(pair<int,int>&p1,pair<int,int>&p2)
{
    if(p1.first == p2.first)return p1.second < p2.second;
    return p1.first < p2.first;
}

int countAirplanes(const vector<vector<int>>& airplanes)
{
    int n = airplanes.size();    
    vector<pair<int,int>>list(n * 2);
    int cnt9 = 0;
    for(int i = 0; i < n ;++i)
    {
        ++cnt9;
        list.push_back(pair<int,int>(airplanes[i][0],1));
        list.push_back(pair<int,int>(airplanes[i][1],-1));
    }         
    sort(list.begin(),list.end(),cmp);
    int cnt = 0;
    int res = 0;
    for(auto airplane:list)
    {             
        if((airplane.first+airplane.second) == 0)continue;   
        if(airplane.second == 1)
        {            
            ++cnt;
        }
        else
        {
            --cnt;    
        }
        
        res = max(cnt,res);        
    }
    return res;

}


bool canAttendMeeting(vector<vector<int>>& meeting)
{
    sort(meeting.begin(),meeting.end());
    for(int i = 0; i < meeting.size(); ++i)
    {
        if(meeting[i][1] > meeting[i+1][0])return false;        
    }
    return true;
}

int minMeetingRooms(vector<vector<int>>& meetings)
{
    int n = meetings.size();
    vector<pair<int,int>>rooms;
    for(int i = 0; i < n; ++i)
    {
        rooms.push_back(pair<int,int>(meetings[i][0],1));
        rooms.push_back(pair<int,int>(meetings[i][1],-1));
    }
    sort(rooms.begin(),rooms.end(),cmp);
    int cnt = 0, res = 0;
    for(auto room:rooms)
    {
        if(room.first + room.second == 0)continue;
        cnt += room.second;
        res = max(res,cnt);
    }
    return res;
}

bool cmp1(pair<int,int>p1,pair<int,int>p2)
{
    return p1.first < p2.first;
}

vector<pair<int,int>>merge(vector<pair<int,int>>& intervals)
{
    vector<pair<int,int>>res;
    int n = intervals.size();
    if(n == 0)return res;
    sort(intervals.begin(),intervals.end(),cmp1);   
    auto cur = intervals[0];
    for(auto next : intervals)
    {
        if(cur.second >= next.first)cur.second = max(cur.second,next.second);
        else
        {
            res.push_back(cur);
            cur = next;
        }
    }
    res.push_back(cur);
    return res;
}

void print(const vector<pair<int,int>>& vs)
{
    for(auto v:vs)
    {
        cout << v.first << " " << v.second << endl;
    }
}

void print(const vector<vector<int>>& nums)
{
    for(auto vs:nums)
    {
        for(auto num : vs)
        {
            cout << num << " ";
        }
        cout << endl;
    }
}

vector<vector<int>>insert(const vector<vector<int>>& intervals,vector<int>& newInterval)
{
    vector<vector<int>>res;
    for(auto cur : intervals)
    {
        if(newInterval.empty() || cur[1] < newInterval[0])
        {
            res.push_back(cur);
        }
        else if(cur[0] > newInterval[1])
        {
            res.push_back(newInterval);
            res.push_back(cur);
            newInterval = {};
        }
        else
        {
            newInterval[0] = min(cur[0],newInterval[0]);
            newInterval[1] = max(cur[1],newInterval[1]);
            
        }
        
    }
    if(!newInterval.empty())res.push_back(newInterval);       
    return res;
}

vector<vector<int>>removeIntervals(const vector<vector<int>>&intervals,const vector<int>&remove)
{
    vector<vector<int>>res;
    for(auto cur : intervals)
    {
        if(cur[0] >= remove[1] || cur[1] <= remove[0])
        {
            res.emplace_back(cur);
        }
        else
        {
            if(cur[0] < remove[0])
            {
                res.push_back({cur[0],remove[0]});
            }
            if(cur[1] > remove[1])
            {
                res.push_back({remove[1],cur[1]});
            }
        }
    }
    return res;
}

int eraseOverlapIntervals(vector<vector<int>>& intervals)
{
    if(intervals.empty())return 0;
    sort(intervals.begin(),intervals.end());    
    int cnt = 0,end = INT_MIN;
    for(auto cur : intervals)
    {
        if(end <= cur[0])end = cur[1];
        else ++cnt;
    }
    return cnt;
}

int removeCoveredIntervals(vector<vector<int>>& intervals)
{
    sort(intervals.begin(),intervals.end());
    int cnt = 0, end = 0;
    for(auto cur : intervals)
    {
        if(end < cur[1])
        {
            end = cur[1];
            ++cnt;
        }
    }
    return cnt;
}

vector<int>minAvailableDuration(vector<vector<int>>&slots1,vector<vector<int>>&slots2,int duration)
{
    sort(slots1.begin(),slots1.end());
    sort(slots2.begin(),slots2.end());
    int n1 = slots1.size(), n2 = slots2.size(),i = 0, j = 0;
    while(i < n1 && j < n2)
    {
        int commonStart = max(slots1[i][0],slots2[j][0]);
        int commonEnd = min(slots1[i][1],slots2[j][1]);        
        if((commonEnd - commonStart) >= duration)
        {
            return {commonStart,commonStart + duration};
        }
        else if(slots1[i][1] < slots2[j][1])++i;
        else ++j;
    }
    return {};
}

void print(const vector<int>& nums)
{
    for(auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
}

vector<vector<int>>intervalIntersection(const vector<vector<int>>&A,const vector<vector<int>>&B)
{
    vector<vector<int>>res;
    int m = A.size(), n = B.size(),i = 0, j =0;
    while(i < m && j < n)
    {
        int low = max(A[i][0],B[j][0]);
        int high = min(A[i][1],B[j][1]);        
        if(low <= high)
        {
            res.push_back({low,high});
        }
        if(A[i][1] < B[j][1]) ++i;
        else ++j;
    }
    return res;
}

bool cmp(vector<int> a, vector<int> b)
{
      return a[0] < b[0];
}

vector<vector<int>> employeeFreeTime(vector<vector<vector<int>>> schedule) {
      vector<vector<int>> v;
      int n = schedule.size();
      for (int i = 0; i < n; i++) {
         for (int j = 0; j < schedule[i].size(); j++) {
            v.push_back(schedule[i][j]);
         }
      }
      sort(v.begin(), v.end());      
      vector<vector<int>> ret;  
      vector<int> temp = v[0];
      for (int i = 0; i < v.size(); i++) {
         if (temp[0] < v[i][1]) {             
             if(temp[1] <= v[i][0])
             {
                ret.push_back({temp[1], v[i][0]});
                
             }
             temp = v[i];
             
         } else {
            temp = temp[1] < v[i][1] ? v[i] : temp;
         }
      }
      return ret;
}

vector<vector<int>> getSkyline(vector<vector<int>>& buildings) {
    auto cmp = [](const pair<int,int>& a,const pair<int,int>& b)->bool {return a.second - b.second;};
    priority_queue<pair<int,int>,vector<pair<int,int>>,decltype(cmp)> que(cmp);       
    vector<int>boundaries;        
    for(auto& building:buildings)
    {
        boundaries.emplace_back(building[0]);
        boundaries.emplace_back(building[1]);
    }        
    sort(boundaries.begin(),boundaries.end());                
    vector<vector<int>>res;
    int n = buildings.size(), idx = 0;        
    for(auto& boundary : boundaries)
    {
        while(idx < n && buildings[idx][0] <= boundary)
        {
            que.emplace(buildings[idx][1],buildings[idx][2]);
            ++idx;
        }
        while(!que.empty() && que.top().first <= boundary)
        {
            que.pop();
        }
        int maxn = que.empty() ? 0 : que.top().second;
        if(res.size() == 0 || maxn != res.back()[1])
        {
            res.push_back({boundary,maxn});
        }

    }        
    return res;        
}

int main()
{

    // ✈️起飞
    vector<vector<int>>airplanes{{1,4},{2,6},{3,7},{4,5}};
    cout << countAirplanes(airplanes) << endl;

    //LeetCode252
    vector<vector<int>>meetings{{0,30},{5,10},{15,20}};
    // meetings = {{7,10},{2,4}};
    cout << canAttendMeeting(meetings) << endl;

    //LeetCode253
    cout << minMeetingRooms(meetings) << endl;

    //LeetCode56
    vector<pair<int,int>>intervals{{1,3},{2,6},{8,10},{9,18}};
    print(merge(intervals));

    //LeetCode57
    vector<vector<int>>intervalss{{1,3},{6,9}};
    vector<int>newInterval{2,5};
    print(insert(intervalss,newInterval));

    //LeetCode1272
    vector<vector<int>>intervals0{{0,2},{3,4},{5,7}};
    vector<int>toBeRemoved{1,6};
    print(removeIntervals(intervals0,toBeRemoved));

    //LeetCode435
    vector<vector<int>>intervals1{{1,2},{3,4},{1,3},{2,3}};
    cout << eraseOverlapIntervals(intervals1) << endl;

    //LeetCode1288
    intervals0 = {{1,4},{3,6},{2,8}};
    cout << removeCoveredIntervals(intervals0) << endl;

    //LeetCode1229
    vector<vector<int>>slots1{{10,50},{60,120},{140,210}};
    vector<vector<int>>slots2{{0,15},{60,70}};
    int duration = 8;
    print(minAvailableDuration(slots1,slots2,duration));

    //LeetCode986

    vector<vector<int>>A{{0,2},{5,10},{13,23},{24,25}};
    vector<vector<int>>B{{1,5},{8,12},{15,24},{25,26}};
    print(intervalIntersection(A,B));

    //LeetCode759
    vector<vector<vector<int>>>schedule{{{1,2},{5,6}},{{1,3}},{{4,10}}};
    print(employeeFreeTime(schedule));

    //LeetCode218
    vector<vector<int>>buildings{{2,9,10},{3,7,15},{5,12,12},{15,20,10},{19,24,8}};
    print(getSkyline(buildings));
    return 0;
}

标签：return,cur,int,res,c++,intervals,vector,扫描线,leetcode
来源： https://www.cnblogs.com/fourmi/p/16223229.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。