线段树+扫描线 NAIPC 2019 Intersecting Rectangles

你看看你有多菜，一点线段树的小小的运用，就不会写了；

题意：如果矩阵有交集，输出1，否则输出0（不包含内嵌）；

思路：本题求交集，还得不包括内嵌的情况；

做过一道是求面积的题。跟这道类似，但在这里定义的方式跟那道题定的相反。

这里把下面的线定为了-1，上面定为了1；

在这道题里，先把矩阵的横向边按上下两种储存在一个结构体里，上的权值为1，下的为-1；

然后离散化这些坐标（为浮点数的时候和数太大的时候都要离散化，太大的话线段树放不下）

所以用离散化后的x1,x2去更新线段树；

当更新的边为下边的时候（权值为-1） 如果这个时候这个区间里已经有值了，证明相交；

当更新的边为上边的时候（权值为1） 如果这个时候这个区间里的值没有变为0，也证明相交；

 #include<cstdio>
 #include<algorithm>
 #include<math.h>
 #include<string.h>
 using namespace std;
 const int maxn=2e5+;
 int cnt1;
 int cnt2,c[maxn];
 struct node
 {
     int l,r,h,id;
 }b[maxn];
 struct Node
 {
     int l,r,sum;
 }tree[maxn<<];
 void init()
 {
     memset(c,,sizeof(c));
     cnt1=cnt2=;
 }
 bool cmp(node x,node y)
 {
     return x.h<y.h;
 }
 void build(int l,int r,int root)
 {
     tree[root].l=l,tree[root].r=r;
     tree[root].sum=;
     if(l==r) return;
     int mid=l+r>>;
     build(l,mid,root<<);
     build(mid+,r,root<<|);
 }
 void pushup(int root)
 {
     tree[root].sum=tree[root<<].sum+tree[root<<|].sum;
 }
 void update(int base,int key,int root)
 {
     int l=tree[root].l,r=tree[root].r;
     if(l==r){
         tree[root].sum+=key;
         return;
     }
     int mid=l+r>>;
     if(mid>=base) update(base,key,root<<);
     else       update(base,key,root<<|);
     pushup(root);
 }
 int query(int L,int R,int root)
 {
     int l=tree[root].l,r=tree[root].r;
     if(l>=L&&r<=R){
         return tree[root].sum;
     }
     int mid=l+r>>;
     int ans=;
     if(mid>=L) ans+=query(L,R,root<<);
     if(mid<R)  ans+=query(L,R,root<<|);
     return ans;
 }
 int main()
 {
     int n;
     while(scanf("%d",&n)!=EOF){
         init();
         for(int i=;i<=n;i++){
             int x1,x2,y1,y2;
             scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
             b[++cnt1].l=x1,b[cnt1].r=x2,b[cnt1].h=y1,b[cnt1].id=-;  //下边；
             b[++cnt1].l=x1,b[cnt1].r=x2,b[cnt1].h=y2,b[cnt1].id=;   //上边；
             c[++cnt2]=x1;     //离散化坐标的预处理；
             c[++cnt2]=x2;     //离散化坐标的预处理；
         }
         sort(c+,c++cnt2);   //离散化
         int len=unique(c+,c++cnt2)-c-;
         for(int i=;i<=cnt1;i++){
             b[i].l=lower_bound(c+,c++len,b[i].l)-c;   //将离散化后的值存储起来
             b[i].r=lower_bound(c+,c++len,b[i].r)-c;
         }
         sort(b+,b++cnt1,cmp);   //从小到排序，这里的操作弄不太清楚，只知道这样子之后
                                   //才能一步一步的去判断是否相交；
         build(,cnt1,);          //建树；
         int flag=;
         for(int i=;i<=cnt1;i++){
             if(b[i].id==-){      //如果为下边
                 int tmp=query(b[i].l,b[i].r,);
                 if(tmp){
                     flag=;
                     break;
                 }
             }
             update(b[i].l,b[i].id,);
             update(b[i].r,b[i].id,);
             if(b[i].id==){
                 int tmp=query(b[i].l,b[i].r,);
                 if(tmp){
                     flag=;
                     break;
                 }
             }
         }
         printf("%d\n",flag);
     }
     return ;
 }