poj1151

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

View Code

#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;

}