hud 1255 覆盖的面积（线段树+离散化）

题目的意思就不用再翻译了

我也是第一次接触离散化，所以理解的也不怎么样。
离散化，把无限空间中无限的个体映射到有限的空间中去，以此提高算法的时空效率。

离散化是程序设计中一个非常常用的技巧，它可以有效的降低时间和空间复杂度。其基本思想就是在众多可能的情况中“只考虑我需要用的值”。下面我将用三个例子说明，如何运用离散化改进一个低效的，甚至根本不可能实现的算法。
《算法艺术与信息学竞赛》中的计算几何部分，黄亮举了一个经典的例子，我认为很适合用来介绍离散化思想。这个问题是UVA10173题目意思很简单，给定平面上n个点的坐标，求能够覆盖所有这些点的最小矩形面积。这个问题难就难在，这个矩形可以倾斜放置（边不必平行于坐标轴）。
UVA10173
UVA10173
这里的倾斜放置很不好处理，因为我们不知道这个矩形最终会倾斜多少度。假设我们知道这个矩形的倾角是α，那么答案就很简单了：矩形面积最小时四条边一定都挨着某个点。也就是说，四条边的斜率已经都知道了的话，只需要让这些边从外面不断逼近这个点集直到碰到了某个点。你不必知道这个具体应该怎么实现，只需要理解这可以通过某种方法计算出来，毕竟我们的重点在下面的过程。
我们的算法很显然了：枚举矩形的倾角，对于每一个倾角，我们都能计算出最小的矩形面积，最后取一个最小值。
这个算法是否是正确的呢？我们不能说它是否正确，因为它根本不可能实现。矩形的倾角是一个实数，它有无数种可能，你永远不可能枚举每一种情况。我们说，矩形的倾角是一个“连续的”变量，它是我们无法枚举这个倾角的根本原因。我们需要一种方法，把这个“连续的”变量变成一个一个的值，变成一个“离散的”变量。这个过程也就是所谓的离散化。
我们可以证明，最小面积的矩形不但要求四条边上都有一个点，而且还要求至少一条边上有两个或两个以上的点。试想，如果每条边上都只有一个点，则我们总可以把这个矩形旋转一点使得这个矩形变“松”，从而有余地得到更小的矩形。于是我们发现，矩形的某条边的斜率必然与某两点的连线相同。如果我们计算出了所有过两点的直线的倾角，那么α的取值只有可能是这些倾角或它减去90度后的角（直线按“\”方向倾斜时）这么C(n,2)种。我们说，这个“倾角”已经被我们“离散化”了。虽然这个算法仍然有优化的余地，但此时我们已经达到了本文开头所说的目的。
对于某些坐标虽然已经是整数（已经是离散的了）但范围极大的问题，我们也可以用离散化的思想缩小这个规模。搞模拟赛Vijos似乎火了一把，我就拿两道Vijos的题开刀。
VOJ1056
VOJ1056
VOJ1056[2] 永远是离散化的经典问题。大意是给定平面上的n个矩形（坐标为整数，矩形与矩形之间可能有重叠的部分），求其覆盖的总面积。平常的想法就是开一个与二维坐标规模相当的二维Boolean数组模拟矩形的“覆盖”（把矩形所在的位置填上True）。可惜这个想法在这里有些问题，因为这个题目中坐标范围相当大（坐标范围为-10^8到10^8之间的整数）。但我们发现，矩形的数量n<=100远远小于坐标范围。每个矩形会在横纵坐标上各“使用”两个值，100个矩形的坐标也不过用了-10^8到10^8之间的200个值。也就是说，实际有用的值其实只有这么几个。这些值将作为新的坐标值重新划分整个平面，省去中间的若干坐标值没有影响。我们可以将坐标范围“离散化”到1到200之间的数，于是一个200*200的二维数组就足够了。实现方法正如本文开头所说的“排序后处理”。对横坐标（或纵坐标）进行一次排序并映射为1到2n的整数，同时记录新坐标的每两个相邻坐标之间在离散化前实际的距离是多少。这道题同样有优化的余地。
最后简单讲一下计算几何以外的一个运用实例（实质仍然是坐标的离散）。VOJ1238[3] 中，标程开了一个与时间范围一样大的数组来储存时间段的位置。这种方法在空间上来看十分危险。一旦时间取值范围再大一点，盲目的空间开销将导致Memory Limit Exceeded。我们完全可以采用离散化避免这种情况。我们对所有给出的时间坐标进行一次排序，然后同样用时间段的开始点和结束点来计算每个时刻的游戏数，只是一次性加的经验值数将乘以排序后这两个相邻时间点的实际差。这样，一个1..n的数组就足够了。
离散化的应用相当广泛，以后你会看到还有很多其它的用途。

代码

#include<stdio.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int N=2010;//x坐标离散化，所以n*2
int n;
struct node
{
    int l,r,k;
    double once;//覆盖一次
    double twice;//覆盖两次
    double lf,rf;//离散化后树种存的y点坐标
}tree[N*3];
struct line
{
    double x,y1,y2;//对x进行离散化
    double flag;
}Line[N];
double yy[N];
bool cmp(line a,line b)
{
    return a.x<b.x;
}
void Build(int i,int left,int right)
{
    tree[i].l=left;
    tree[i].r=right;
    tree[i].once=tree[i].twice=0;
    tree[i].lf=yy[left];//线段树中存入纵坐标
    tree[i].rf=yy[right];
    if(left+1==right)
        return ;
    int mid=(left+right)>>1;
    Build(i*2,left,mid);
    Build(i*2+1,mid,right);
}
void find (int i)
{
    if(tree[i].k>=2)
    {
        tree[i].twice=tree[i].once=tree[i].rf-tree[i].lf;
        return ;
    }
    else if(tree[i].k==1)
    {
        tree[i].once=tree[i].rf-tree[i].lf;
        if(tree[i].l+1==tree[i].r)
            tree[i].twice=0;
        else
            tree[i].twice=tree[i*2].once+tree[i*2+1].once;
    }
    else
    {
         if(tree[i].l+1==tree[i].r)
           tree[i].once=tree[i].twice=0;
         else
         {
             tree[i].once=tree[i*2].once+tree[i*2+1].once;
             tree[i].twice=tree[i*2].twice+tree[i*2+1].twice;
         }
    }
}
void update(int i,line q)
{
    if(q.y1==tree[i].lf&&q.y2==tree[i].rf)
    {
        tree[i].k+=q.flag;
        find(i);
        return ;
    }
    else if(tree[i*2].rf>=q.y2)
        update(i*2,q);
    else if(tree[i*2+1].lf<=q.y1)
    {
        update(i*2+1,q);
    }
    else
    {
        line temp=q;
        temp.y2=tree[i*2].rf;
        update(i*2,temp);
        temp=q;
        temp.y1=tree[i*2+1].lf;
        update(i*2+1,temp);
    }
  find(i);
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stout);
    double x1,y1,x2,y2;
    int T,t;
    double sum;
    scanf("%d",&T);
    while(T--)
    {
        t=1;
        sum=0;
        scanf("%d",&n);
        for(int i=1; i<=n; i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);//应该是左下角和右上角
            Line[t].x=x1;
            Line[t].y1=y1;
            Line[t].y2=y2;
            Line[t].flag=1;
            yy[t]=y1;
            t++;
            Line[t].x=x2;
            Line[t].y1=y1;
            Line[t].y2=y2;
            Line[t].flag=-1;
            yy[t]=y2;
            t++;
        }
       sort(Line+1,Line+t,cmp);
       sort(yy+1,yy+t);
       Build(1,1,t-1);
       update(1,Line[1]);
       for(int i=2;i<t;i++)
       {
           sum+=tree[1].twice*(Line[i].x-Line[i-1].x);
           update(1,Line[i]);
       }
       printf("%.2lf\n",sum);
    }
    return 0;
}