UVALive 4171 Bulletin Board

Problem E: Bulletin Board

Source file:	bulletin.{c, cpp, java}
Input file:	bulletin.in

The ACM Student Chapter has just been given custody of a number of school bulletin boards. Several members agreed to clear off the old posters. They found posters plastered many levels deep. They made a bet about how much area was left clear, what was the greatest depth of posters on top of each other, and how much of the area was covered to this greatest depth. To determine each bet's winner, they made very accurate measurements of all the poster positions as they removed them. Because of the large number of posters, they now need a program to do the calculations. That is your job. 

A simple illustration is shown above: a bulletin board 45 units wide by 40 high, with three posters, one with corners at coordinates (10, 10) and (35, 20), another with corners at (20, 25) and (40, 35), and the last with corners at (25, 5) and (30, 30). The total area not covered by any poster is 1300. The maximum number of posters on top of each other is 2. The total area covered by exactly 2 posters is 75.

Input: The input will consist of one to twenty data sets, followed by a line containing only 0. On each line the data will consist of blank separated nonnegative integers. 

The first line of a dataset contains integers n w h, where n is the number of posters on the bulletin board, w and h are the width and height of the bulletin board. Constraints are 0 < n ≤ 100; 0 < w ≤ 50000; 0 < h ≤ 40000. 

The dataset ends with n lines, each describing the location of one poster. Each poster is rectangular and has horizontal and vertical sides. The x and y coordinates are measured from one corner of the bulletin board. Each line contains four numbers xlylxh and yh, where xl and yl, are the lowest values of the x and y coordinates in one corner of the poster and xh and yh are the highest values in the diagonally opposite corner. Each poster fits on the bulletin board, so 0 ≤ xl < xh ≤ w, and 0 ≤ yl < yh ≤ h. 

Output: There is one line of output for each data set containing three integers, the total area of the bulletin board that is not covered by any poster, the maximum depth of posters on top of each other, and the total area covered this maximum number of times. 

Caution: An approach examining every pair of integer coordinates might need to deal with 2 billion coordinate pairs. 

Example input:	Example output:
3 45 40 10 10 35 20 20 25 40 35 25 5 30 30 1 20 30 5 5 15 25 2 2000 1000 0 0 1000 1000 1000 0 2000 1000 3 10 10 0 0 10 10 0 0 10 10 0 0 10 10 0	1300 2 75 400 1 200 0 1 2000000 0 3 100

题目大意：在一个平面中给出若干个矩形，会有重叠覆盖的情况，求未被矩形覆盖的面积，以及被矩形覆盖最多次的区域被覆盖了几次，和它的面积。

一道很典型的离散化的题目。这里先介绍离散化。

有篇博客讲的很透彻 ，在这里推荐一下  http://www.cppblog.com/MiYu/archive/2010/10/15/129999.aspx

于是思路就很简单，离散化后用book表来记录，0代表为覆盖，非0代表覆盖，每有一层数字加一。

代码如下：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
int  buf[202][202];
int column[202];
int line[202];
int book[202][202];
int data[101][4];
int main()
{
    int n,w,h,column_counter,line_counter,c,l,chead,ctail,lhead,ltail,t,max,sum,sum1;
    while(scanf("%d",&n),n!=0)
    {
        max=-1;
        sum=sum1=0;
        memset(book,0,sizeof(book));
        column_counter=line_counter=1;
        line[0]=column[0]=0;
        scanf("%d%d",&w,&h);
        for(int i=0;i<n;i++)
        {
            scanf("%d%d%d%d",&data[i][0],&data[i][1],&data[i][2],&data[i][3]);
            line[line_counter++]=data[i][0];
            column[column_counter++]=data[i][1];
            line[line_counter++]=data[i][2];
            column[column_counter++]=data[i][3];
        }
        sort(line,line+line_counter);
        l=unique(line,line+line_counter)-line;
        sort(column,column+column_counter);
        c=unique(column, column+column_counter)-column;
        for(int i=1;i<l;i++)
        {
            buf[0][i]=line[i]-line[i-1];
            //printf("%d ",buf[0][i]);
        }
        for(int i=1;i<c;i++)
        {
            buf[i][0]=column[i]-column[i-1];
            //printf("%d ",buf[i][0]);
        }
        for(int i=1;i<c;i++)
            for(int t=1;t<l;t++)
            {
                buf[i][t]=buf[i][0]*buf[0][t];
            }
        /*for(int i=1;i<c;i++)
        {
            for(int t=1;t<l;t++)
            {
                printf("%d ",buf[i][t]);
            }
            printf("\n");
        }*/
        for(int i=0;i<n;i++)
        {
            for(t=0;t<l;t++)
            {
                if(line[t]==data[i][0])
                {
                    lhead=t;
                    break;
                }
            }
            for(;t<l;t++)
            {
                if(line[t]==data[i][2])
                {
                    ltail=t;
                    break;
                }
            }
            for(t=0;t<c;t++)
            {
                if(column[t]==data[i][1])
                {
                    chead=t;
                    break;
                }
            }
            for(;t<l;t++)
            {
                if(column[t]==data[i][3])
                {
                    ctail=t;
                    break;
                }
            }
            for(int k=chead+1;k<=ctail;k++)
                for(int p=lhead+1;p<=ltail;p++)
                {
                    book[k][p]++;
                }
            /*printf("c %d  l %d",c,l);
            for(int k=0;k<=c;k++)
            {
                for(int p=0;p<=l;p++)
                {
                    printf("%d ",book[k][p]);
                }
                printf("\n");
            }*/
        }
        for(int k=0;k<=c;k++)
            for(int p=0;p<=l;p++)
            {
                if(book[k][p]>max)
                    max=book[k][p];
                if(book[k][p]!=0)
                {
                    sum+=buf[k][p];
                }
            }
        for(int k=0;k<=c;k++)
            for(int p=0;p<=l;p++)
            {
                if(book[k][p]==max)
                {
                    sum1+=buf[k][p];
                }
            }
        printf("%d %d %d\n",w*h-sum,max,sum1);
        
    }
}