一道离散化+线段树+扫描线的题

http://poj.org/problem?id=1151

这道题感觉快哭了  卡了一个差不多礼拜  然后发现 输出用%.2lf是过不了的  必须用%.2f才能过 这是一道好（lan）题；

%f 一般对应单精度类型 float
%lf 一般对应双精度类型 double

#include<iostream>
#include<algorithm>
#include<cmath>
#include<set>
#include<cstdio>

using namespace std;

double y[210];
typedef struct _NODE_
{
    int L,R;
    _NODE_ *PLeft,*PRight;
    double Len;   //当前,本区间上有多长的部分是落在那些矩形中的
    int Covers;   //本区间当前被多少个矩形完全包含
}NODE;

NODE Tree[10000];

typedef struct _LINE_
{
    double x,y,y1,y2;
    bool bLeft;      //是否是矩形的左边
}LINE;

LINE Line[210];

int iNodeCount = 0;
bool operator < (const LINE& l1,const LINE& l2)
{
    return l1.x < l2.x;
}
template<class F,class T>
F bin_search(F s,F e,T val)
{
    F  L = s;
    F  R = e-1;
    while (L<=R)
    {
        F mid = L+(R-L)/2;
        if (!(*mid<val||val<*mid))
        {
            return mid;
        }
        else if (val<*mid)
        {
            R = mid-1;
        }
        else 
        {
            L = mid+1;
        }
    }
    return e;
}
int Mid(NODE* PRoot)
{
    return (PRoot->L+PRoot->R)>>1;
}
void Insert(NODE* PRoot,int L,int R)
{
    if (PRoot->L==L&&PRoot->R==R)
    {
        PRoot->Len = y[R+1]-y[L];
        PRoot->Covers++;
        return ;
    }
    if (R <= Mid(PRoot))
    {
        Insert(PRoot->PLeft,L,R);
    }
    else if (L>=Mid(PRoot)+1)
    {
        Insert(PRoot->PRight,L,R);
    }
    else 
    {
        Insert(PRoot->PLeft,L,Mid(PRoot));
        Insert(PRoot->PRight,Mid(PRoot)+1,R);
    }
    if (PRoot->Covers==0) //如果不为0，则说明本区间当前仍然被某个矩形完全包含，则不能更新 Len
    {
        PRoot->Len = PRoot->PLeft->Len + PRoot->PRight->Len;
    }
}


void Delete(NODE* PRoot,int L,int R) //在区间pRoot 删除矩形右边的一部分或全部，该矩形右边的一部分或全部覆盖了区间[L,R]
{
    if (PRoot->L==L&&PRoot->R==R)
    {
        PRoot->Covers--;
        if (PRoot->Covers==0)
        {
            if (PRoot->L==PRoot->R)
            {
                PRoot->Len = 0;
            }
            else 
            {
                PRoot->Len = PRoot->PLeft->Len+PRoot->PRight->Len;
            }
        }
        return ; 
    }
    if (R<=Mid(PRoot))
    {
        Delete(PRoot->PLeft,L,R);
    }
    else if (L>=Mid(PRoot)+1)
    {
        Delete(PRoot->PRight,L,R);
    }
    else 
    {
        Delete(PRoot,L,Mid(PRoot));
        Delete(PRoot->PRight,Mid(PRoot)+1,R);
    }
    if (PRoot->Covers==0) //如果不为0，则说明本区间当前仍然被某个矩形完全包含，则不能更新 Len
    {
        PRoot->Len = PRoot->PLeft->Len+PRoot->PRight->Len;
    }
}

void BuildTree(NODE* PRoot,int L,int R)
{
    PRoot->L = L;
    PRoot->R = R;
    PRoot->Covers = 0;
    PRoot->Len = 0;
    if (L == R)
    return ;
    iNodeCount++;
    PRoot->PLeft = Tree + iNodeCount;
    iNodeCount++;
    PRoot->PRight = Tree+ iNodeCount;
    BuildTree(PRoot->PLeft,L,(L+R)/2);
    BuildTree(PRoot->PRight,(L+R)/2+1,R);
}


void work()
{
    int i,j,k,n;
    double x1,x2,y1,y2;
    int yc,lc;
    int iCount = 0;
    int t = 0;
    
//yc 是横线的条数，yc- 1是纵向区间的个数，这些区间从0
//开始编号，那么最后一个区间
//编号就是yc - 1 -1
    while (~scanf("%d",&n)&&n)
    {
        t++; yc = lc = 0;
        for (i = 0;i<n;i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            y[yc++] = y1;  y[yc++] = y2;
            Line[lc].x = x1; Line[lc].y1 = y1;
            Line[lc].y2 = y2; Line[lc].bLeft = true;
            lc++;
            Line[lc].x = x2;  Line[lc].y1 = y1;
            Line[lc].y2 = y2; Line[lc].bLeft = false;
            lc++;
        }
        sort(y,y+yc);
        yc = unique(y,y+yc)-y;
        iNodeCount = 0;
        BuildTree(Tree,0,yc-1-1);
        sort(Line,Line+lc);
        double Area = 0;
        for (i = 0;i<lc-1;i++)
        {
            int L = bin_search(y,y+yc,Line[i].y1)-y;
            int R = bin_search(y,y+yc,Line[i].y2)-y;
            if (Line[i].bLeft)
            {
                Insert(Tree,L,R-1);
            }
            else 
            {
                Delete(Tree,L,R-1);
            }
            Area += Tree[0].Len*(Line[i+1].x-Line[i].x);
        }
        printf("Test case #%d
",t);
        printf("Total explored area: %.2f
",Area);
        printf("
");
    }
    return ;
}

int main()
{
    work();
    return 0;
}