codeforces 1284D. New Year and Conference（线段树）

题意：有n场讲座，有两个场地a和b，如果在a场地开讲座则需要占用[sai,eai],在b场地开讲座则需要占用[sbi,ebi]这个时间段,假如开两场讲座,如果在a场地开不冲突,而b场地开冲突,则称其为敏感的，同理a和b反过来也是一样的,如果ab两场地都冲突则也不是敏感的，先求给定的n场讲座,任意的两两开设是否敏感。

思路：暴力枚举是O（n^2）复杂度，必定超时，这里可以用线段树或ST表做，达到一个nlogn的复杂度。对于任意一个讲座x，找出所有与x讲座在a场地冲突的讲座，再判断其是否在b场地冲突，如果不是则直接输出“NO”

首先对所有讲座的sa和ea进行升序，例如讲座 i 的时间片是[x,y]，在其时间片上与 i 在a场地冲突的讲座用二分的方法可以枚举出来一个离散化后的区间，然后我们用线段树维护b场地的sb最大值和eb最小值，每次查询出这个区间的

的sb最大值和eb最小值，此时如果说sb最大值 > y 或者 eb最小值 < x,那么这些表演中必定存在b场地与表演i不冲突的情况，此时直接输出“NO”，把所有的讲座都check一遍，交换ab次序再check即可，上述只检验了在a场地冲突一定在b场地冲突的情况，但并未考虑在b场地冲突而在a场地不冲突的情况。

总体时间复杂度nlogn。

AC代码:

 #include<iostream>
 #include<vector>
 #include<cstdlib>
 #include<cstdio>
 #include<algorithm>
 #include<cmath>
 #include<cstring>
 #include<queue>
 #include<map>
 using namespace std;
 typedef long long ll;
 const int maxn = 1e5+;
 struct node{
     int sa,ea,sb,eb;
     node(){};
     node(int a,int b,int c,int d){
         sa = a,ea = b,sb = c,eb = d;
     }
     bool operator<(node cur)const{
         if(sa == cur.sa ) return ea<cur.ea ;
         return sa < cur.sa ;
     }
 }point[maxn];
 int segt_max[*maxn],segt_min[*maxn];
 void build(int l,int r,int k){//建两个线段树维护区间最大最小值
     if(l == r) {
         segt_max[k] = point[l].sb;
         segt_min[k] = point[l].eb;
         return ;
     }
     int mid = (l+r)/;
     build(l,mid,*k);
     build(mid+,r,*k+);
     segt_max[k] = max(segt_max[*k],segt_max[*k+]);
     segt_min[k] = min(segt_min[*k],segt_min[*k+]);
 }
 int queryMin(int l,int r,int al,int ar,int k){//查询区间最小值
     if(l >= al && r <= ar) return segt_min[k];
     int mid = (l+r)/;
     if(ar<=mid) return queryMin(l,mid,al,ar,*k);
     else if(al>mid){
         return queryMin(mid+,r,al,ar,*k+);
     }
     else {
         return min(queryMin(l,mid,al,mid,*k),queryMin(mid+,r,mid+,ar,*k+));
     }
 }
 int queryMax(int l,int r,int al,int ar,int k){//查询区间最大值
     if(l >= al && r <= ar) return segt_max[k];
     int mid = (l+r)/;
     if(ar<=mid) return queryMax(l,mid,al,ar,*k);
     else if(al>mid){
         return queryMax(mid+,r,al,ar,*k+);
     }
     else {
         return max(queryMax(l,mid,al,mid,*k),queryMax(mid+,r,mid+,ar,*k+));
     }
 }
 bool check(int n){
     sort(point+,point++n);
     build(,n,);
     for(int i = ;i<=n;i++){
         int pos = lower_bound(point+,point++n,node(point[i].ea ,1e9+,,))-point-;
         //查找与第i场演讲冲突的集合
         if(i+>pos) continue;//无冲突直接跳过
         //check一下另一个场地的所有表演是否都冲突
         if(queryMin(,n,i+,pos,)<point[i].sb || queryMax(,n,i+,pos,)>point[i].eb){
             return false;
         }
     }
     return true;
 }
 int main()
 {
     int n;
     cin>>n;
     int f = ;
     for(int i = ;i<=n;i++){
         cin>>point[i].sa>>point[i].ea>>point[i].sb>>point[i].eb;
     }
     if(check(n)) f++;
     for(int i = ;i<=n;i++){
         swap(point[i].sa,point[i].sb);
         swap(point[i].ea,point[i].eb);
     }
     if(check(n)) f++;
     if(f == ) cout<<"YES";
     else cout<<"NO";
     return ;
 }