New Year and Conference（线段树）

传送门

题意：给你n组有俩个区间段A和B的数据，问你是否A相交时B也相交或者都不相交。

题解：将端点离散化后按A左端点排序，另开一个数组按A右端点排序，按左端点将A加入，通过第二个结构体将A删除，同时对应增加或删除B区间，那么当前留下的A区间都是相交的，同时用线段树维护被B区间最多的覆盖次数，那么每次删除时，留下的A区间数等于B的最大覆盖数，然后反转AB区间在处理一次就可以得到答案，复杂度O(nlongn);

#include<stdio.h>
#include<vector>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<math.h>
#include<queue>
#include<set>
#include<map>
#include<stack>
#define ll long long
#define fo(n) for(int i=1;i<=n;i++)
#define fol(n) for(int i=n;i>=1;i--)
#define foj(i,n) for(int j=i;j<=n;j++)
#define fok(i,j) for(int k=i;k<=j;k++)
#define oui(i) printf("%d\n",i)
#define oul(i) printf("%lld\n",i)
#define sc(n) scanf("%d",&n)
#define scl(n) scanf("%lld",&n)
#define mid ((l+r)>>1)
#define ls k<<1
#define rs (k<<1)+1
using namespace std;
int read(){
    char c;int x=0,y=1;while(c=getchar(),(c<'0'||c>'9')&&c!='-');
    if(c=='-') y=-1;else x=c-'0';while(c=getchar(),c>='0'&&c<='9')
        x=x*10+c-'0';return x*y;
}
const int maxn=1e5+10;
const int inf=1e7;
struct node{
    int a1,a2,b1,b2;
};
node ai[maxn],ci[maxn];
int bi[maxn*4];
int tree[maxn*16],lazy[maxn*16];
bool cmp(node a,node b){
    return a.a1<b.a1;
}
bool cmp1(node a,node b){
    return a.a2<b.a2;
}
void build(int l,int r,int k){
    tree[k]=lazy[k]=0;
    if(l==r) return ;
}
void pushdown(int k){
    tree[ls]+=lazy[k];
    tree[rs]+=lazy[k];
    lazy[ls]+=lazy[k];
    lazy[rs]+=lazy[k];
    lazy[k]=0;
}
void modify1(int l,int r,int l1,int r1,int k,int va){
    if(l>=l1&&r<=r1){
        lazy[k]+=va;
        tree[k]+=va;
        return ;
    }
    if(lazy[k]) pushdown(k);
    if(mid>=l1) modify1(l,mid,l1,r1,ls,va);
    if(mid+1<=r1) modify1(mid+1,r,l1,r1,rs,va);
    tree[k]=max(tree[ls],tree[rs]);
}
int work(int n,int num){
    sort(ai+1,ai+n+1,cmp);
    sort(ci+1,ci+n+1,cmp1);
    int k1=1,k2=1,num1=0;
    build(1,num,1);
    for(int a=1;a<=num+1;a++){
        for(;k2<=n;k2++){
            if(ci[k2].a2<a){
                if(num1!=tree[1]){
                    return 0;
                }
                num1--;
                modify1(1,num,ci[k2].b1,ci[k2].b2,1,-1);
            }
            else
                break;
        }
        for(;k1<=n;k1++){
            if(ai[k1].a1==a)
                modify1(1,num,ai[k1].b1,ai[k1].b2,1,1),num1++;
            else
                break;
        }
    }
    return 1;
}
int main( ){
    int n=read();
    for(int a=1;a<=n;a++){
        int b=(a-1)*4+1;
        bi[b]=ai[a].a1=read();
        bi[b+1]=ai[a].a2=read();
        bi[b+2]=ai[a].b1=read();
        bi[b+3]=ai[a].b2=read();
    }
    sort(bi+1,bi+n*4+1);
    int num=unique(bi+1,bi+n*4+1)-bi;
    for(int a=1;a<=n;a++){
        ai[a].a1=lower_bound(bi+1,bi+num,ai[a].a1)-bi;
        ai[a].a2=lower_bound(bi+1,bi+num,ai[a].a2)-bi;
        ai[a].b1=lower_bound(bi+1,bi+num,ai[a].b1)-bi;
        ai[a].b2=lower_bound(bi+1,bi+num,ai[a].b2)-bi;
        ci[a]=ai[a];
    }
    int c1=work(n,num);
    for(int a=1;a<=n;a++){
        swap(ai[a].a1,ai[a].b1);
        swap(ai[a].a2,ai[a].b2);
        ci[a]=ai[a];
    }
    c1+=work(n,num);
    if(c1==2)
    printf("YES\n");
    else
        printf("NO\n");
}