poj1151

本来是离散化的题，当初用了一种比较与众不同的做法

#include <iostream>
#include <cstdlib>
#include <iomanip>
using namespace std;

const    int        maxn=500;

struct    cube
{
    double    l,r,u,d;
};

void    init();
void    work();
void    print();
void    cut(int j);

int        n,no=0,tot;
double    ans;
cube    c[maxn],ls;

int main()
{
    while (true)
    {
        init();
        work();
        print();
    }
    return 0;
}

void init()
{
    int        i,j;
    
    ans=0;
    tot=0;
    cin>>n;
    if (n==0)
        exit(0);
    for (i=1;i<=n;i++)
    {
        cin>>ls.l>>ls.d>>ls.r>>ls.u;
        for (j=1;j<=tot;j++)
            cut(j);
        tot++;
        c[tot]=ls;
    }
}

void work()
{
    int        i;

    for (i=1;i<=tot;i++)
        ans+=(c[i].u-c[i].d)*(c[i].r-c[i].l);
}

void cut(int j)
{
    if (c[j].d>=ls.u||c[j].u<=ls.d||c[j].l>=ls.r||c[j].r<=ls.l||j>tot)
        return;
    if (c[j].u>ls.u)
    {
        tot++;
        c[tot].u=c[j].u;
        c[tot].l=c[j].l;
        c[tot].r=c[j].r;
        c[tot].d=ls.u;
        c[j].u=ls.u;
    }
    if (c[j].d<ls.d)
    {
        tot++;
        c[tot].d=c[j].d;
        c[tot].l=c[j].l;
        c[tot].r=c[j].r;
        c[tot].u=ls.d;
        c[j].d=ls.d;
    }
    if (c[j].r>ls.r)
    {
        tot++;
        c[tot].r=c[j].r;
        c[tot].u=c[j].u;
        c[tot].d=c[j].d;
        c[tot].l=ls.r;
        c[j].r=ls.r;
    }
    if (c[j].l<ls.l)
    {
        tot++;
        c[tot].l=c[j].l;
        c[tot].u=c[j].u;
        c[tot].d=c[j].d;
        c[tot].r=ls.l;
        c[j].l=ls.l;
    }
    c[j]=c[tot];
    tot--;
    cut(j);
}

void print()
{

    no++;
    cout<<"Test case #"<<no<<endl;
    cout<<"Total explored area: "<<fixed<<setprecision(2)<<ans<<endl;
    cout<<endl;
}