矩形

题目描述
因为对polo忍无可忍， dzf使用圣剑在地上划出了许多纵横交错的沟壑来泄愤。这些沟壑都严格与X轴平行或垂直。
polo嘲笑了dzf无聊的行为，然后做了一件更加无聊的事。他蹲下来数这些沟壑的条数。数着数着，polo意识到一个问题，那就是因为圣剑的威力太大，划出的沟壑太多，地面就会塌陷。而如果两条水平的沟壑和两条垂直的沟壑相交组成了一个矩形，那么塌陷的危险就会进一步增加。现在polo已经数了n条沟壑，他想知道这些沟壑组成了多少个矩形。

输入
第一行一个数n,接下来每行4个数x1,y1,x2,y2，表示沟壑的两个端点(x1,y1),(x2,y2)
输出
一个数，组成的矩形个数。
样例输入
4
0 0 1 0
0 0 0 1
1 1 1 -1
1 1 0 1

8
1 0 4 0
2 1 2 0
0 0 0 3
2 2 2 3
3 3 3 -1
0 3 4 3
4 1 -1 1
3 2 -1 2
样例输出
1
6
提示
【数据说明】
对于30%的数据，1<=n<=100
对于60%的数据，1<=n<=600
对于100%的数据，1<=n<=2000,坐标绝对值小于10^9，任意两条与X轴水平的沟壑之间没有交点，任意两条与X轴垂直的沟壑没有交点。

Solution

对于30%的数据，枚举两条水平的线段，再枚举两条垂直的线段，判断是否两两相交即可。时间复杂度$O(n^4)$
对于60%的数据，枚举两条垂直的线段，再统计有多少条水平线段与这两条线段相交，记为k。那么这两条垂直的线段和所有水平线段组成的矩形个数记为$C(k,2)$，累加进答案即可。时间复杂度$O(n^3)$。
对于100%的数据，将垂直的线段按x排序，枚举垂直线段i，然后把所有与i相交的水平线段添加进线段树，然后枚举j线段，因为x是单调的，所以我们可以随着j的增加删除线段树中的线段，k的值就是在线段树中查询。线段树的区间是y坐标的区间。时间复杂度$O(n^2log(n))$

#include<cstdio>
#include<iostream>
#include<algorithm>
#define y1 yl
#define ll long long
#define p1 id<<1
#define p2 id<<1^1
using namespace std;
int n,x,la,lb,len,tot;
int x1,y1,x2,y2;
ll ans;
struct ty
{
    int x1,y1,x2,y2;
}a[2005],b[2005],c[2005];
int num[10005],li[10005];
int tree[10005];
bool cmp(ty a,ty b)
{
    return a.x1<b.x1; 
}
bool fuck(ty a,ty b)
{
    return a.x2<b.x2;
}
int query(int id,int l,int r,int x,int y)
{
    if(x<=l&&r<=y) return tree[id];
    int mid=(l+r)/2;
    if(y<=mid) return query(p1,l,mid,x,y);
    else
    if(x>mid) return query(p2,mid+1,r,x,y);
    else return query(p1,l,mid,x,mid)+query(p2,mid+1,r,mid+1,y);
}
void update(int id,int l,int r,int x,int y)
{
    if(l==r) 
    {
        tree[id]=tree[id]+y; 
        return;
    }
    int mid=(l+r)/2;
    if(x<=mid) update(p1,l,mid,x,y);
    else update(p2,mid+1,r,x,y);
    tree[id]=tree[p1]+tree[p2];
}
void build(int id,int l,int r)
{
    if(l==r) 
    {
        tree[id]=0;
        return;
    }
    int mid=(l+r)/2;
    build(p1,l,mid);
    build(p2,mid+1,r);
    tree[id]=0;
}
int search(int l,int r,int x)
{
    int mid=(l+r)/2;
    if(num[mid]==x) return li[mid];
    if(x>num[mid]) return search(mid+1,r,x); 
    else search(l,mid-1,x);
}
void lisanhua() //离散化y坐标
{
    for(int i=1;i<=la;i++) 
    {
        tot++;
        num[tot]=a[i].y1;
        tot++;
        num[tot]=a[i].y2;
    }
    for(int i=1;i<=lb;i++) 
    {
        tot++;
        num[tot]=b[i].y1;
        tot++;
        num[tot]=b[i].y2;
    }
    sort(num+1,num+tot+1);
    x=1;li[1]=1;
    for(int i=2;i<=tot;i++) 
    {
        if(num[i]!=num[i-1]) x++;
        li[i]=x;
    }
    for(int i=1;i<=la;i++) 
    {
        a[i].y1=search(1,tot,a[i].y1);
        a[i].y2=search(1,tot,a[i].y2);
    }
    for(int i=1;i<=lb;i++) 
    {
        b[i].y1=search(1,tot,b[i].y1);
        b[i].y2=search(1,tot,b[i].y2);
    }
}
int erfen(int l,int r,int x)
{
    if(l>r) return l;
    int mid=(l+r)/2;
    if(x>c[mid].x2) return erfen(mid+1,r,x);
    else return erfen(l,mid-1,x);
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) 
    {
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        if(x1==x2) //垂直 
        {
            la++;
            a[la].x1=x1; 
            a[la].x2=x2;
            a[la].y1=y1;
            a[la].y2=y2; 
            if(a[la].y1>a[la].y2) swap(a[la].y1,a[la].y2);
        }
        if(y1==y2)//水平 
        {
            lb++;
            b[lb].x1=x1;
            b[lb].x2=x2;
            b[lb].y1=y1;
            b[lb].y2=y2; 
            if(b[lb].x1>b[lb].x2) swap(b[lb].x1,b[lb].x2);
        }
    }
    sort(a+1,a+la+1,cmp);
    lisanhua(); 
    for(int i=1;i<=la;i++) 
    {
        build(1,1,x); 
        len=0; 
        for(int j=1;j<=lb;j++) 
        if(a[i].y1<=b[j].y1&&b[j].y1<=a[i].y2) 
        if(b[j].x1<=a[i].x1&&a[i].x1<=b[j].x2) //保存所有和i相交的水平线段 
        {
            len++;
            c[len].x1=b[j].x1;
            c[len].x2=b[j].x2;
            c[len].y1=b[j].y1;
            c[len].y2=b[j].y2;
            update(1,1,x,c[len].y1,1); 
        }
        sort(c+1,c+len+1,fuck); 
        int pre=1; 
        for(int j=i+1;j<=la;j++) 
        if(a[j].x1>a[i].x1) 
        {
            int id=erfen(pre,len,a[j].x1); 
            for(int k=pre;k<id;k++) update(1,1,x,c[k].y1,-1); //线性删除水平线段，因为pre是单调递增的，时间是平行的O(n)
            pre=id;
            int s=0;
            int down=max(a[i].y1,a[j].y1);
            int up=min(a[i].y2,a[j].y2);
            if(down<=up) s=query(1,1,x,down,up); 
            ans=ans+(ll)(s)*(s-1)/2; 
        }
    }
    cout<<ans;
    return 0;
}