UESTC_秋实大哥与家 2015 UESTC Training for Data Structures<Problem E>

E - 秋实大哥与家

Time Limit: 3000/1000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others)

Submit Status

秋实大哥是一个顾家的男人，他认为人生就是旅途，不管我们漂到哪，最终还是会回到温暖的地方——家。

所以他买了很多家具。

秋实大哥的家可以看成一个W×H的矩阵，每一件家具可以看成一个矩形，他们放置在秋实大哥的家里，相互之间没有重叠。

现在秋实大哥购置了一个新的大小为1×M的家具，秋实大哥想知道他有多少种方式来安放这个家具。

Input

第一行包含四个整数W，H，n，M，表示秋实大哥家的大小为W×H，现在已有n个家具，新购置的家具大小为1×M。

接下来n行，每行包含4个整数x1，y1，x2，y2，分别表示这个家具左下角的坐标和右上角的坐标。

1≤n，H，W，M≤100000，1≤x1≤x2≤W，1≤y1≤y2≤H。

Output

输出一行包含一个整数，表示有多少种方案可以来放置秋实大哥的新家具，要求不能跟原有的家具重叠，也不能超出家的范围。

Sample input and output

Sample Input	Sample Output
3 3 1 2 2 2 2 2	8

解题报告:

注意到所有的家具是1 x m的，不外乎横放与竖放，我们先考虑横放，对于每个矩形，其左端线坐标为x1,右端线坐标为x2.

那么下列这些点肯定无法放置的（以这些点为最左端放置)

 (X1-m+1,x2) , y ∈ [y1,y2]

那么问题就好解决了，每读入一个矩形，将其线延长，之后算不合法的面积，用总面积减去不合法的面积即为方案数.

竖放的道理一样，这里不再阐述.注意到 m = 1的情况，横 / 竖是一样的

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
typedef long long ll;
using namespace std;
const int maxn = 6e5 + 50;
const int maxtreesize = 6e5 + 50;
int w,h,n,m,size=0;

typedef struct node
{
int l,r,cover,sum;
};

node tree[maxtreesize];

void push_up(int cur)
{
   int lc = 2*cur;
   int rc = 2*cur+1;
   if (tree[cur].cover)
    tree[cur].sum = tree[cur].r - tree[cur].l;
   else if(tree[cur].l == tree[cur].r ) // 叶子 
    tree[cur].sum = 0;
   else
    {
       if (tree[lc].cover && tree[rc].cover )   // Updata Father
        tree[cur].sum = tree[lc].sum + tree[rc].sum;
       else
        tree[cur].sum = tree[lc].sum + tree[rc].sum;
    }
    
}


void updata(int ql,int qr,int v,int cur)
{
  int lc = 2*cur , rc = 2*cur + 1 , l = tree[cur].l , r = tree[cur].r;
  if (r == l) // 元 
   return;
  if (l >= ql && r <= qr)
   {
         tree[cur].cover += v;
         push_up(cur);
   }
  else
   {
         int mid = l + (r-l)/2;
         if (mid > ql)
          updata(ql,qr,v,lc);
         if (mid < qr)
          updata(ql,qr,v,rc);
         push_up(cur);
   }
}

void build_tree(int cur,int l,int r)
{
    tree[cur].l = l,tree[cur].r = r;
    if (r - l > 1 )
     {
          int mid = l + (r-l)/2;
          build_tree(2*cur,l,mid);
          build_tree(2*cur+1,mid,r);
     }
}


typedef struct line
{
  int x1,x2,y1,y2;
  bool flag; // 0 是入边，1 是出边 
  inline int getx()
   {
         if (flag)
          return x2;
         else
          return x1;
   }
  inline int gety()
   {
         if (flag)
          return y2;
         else
          return y1;
   }
};

line a[maxn]; // x 方向上被限制 
line b[maxn]; // y 方向上被限制 

bool cmp1(line a,line b)
{
   return a.getx() < b.getx();
}

bool cmp2(line a,line b)
{
   return a.gety() < b.gety();
}

void dump__()
{
   for(int i = 0 ; i < size ; ++ i)
    {
        if (a[i].flag == 0)
         {
             printf("入边 , x is %d , y1 is %d, y2 is %d
",a[i].getx(),a[i].y1 , a[i].y2);
         }
        else
         printf("出边 , x is %d , y1 is %d, y2 is %d
",a[i].getx(),a[i].y1 , a[i].y2);
    }
}

void dump()
{
    for(int i = 0 ; i < size ; ++ i)
    {
       if (b[i].flag == 0)
        {
            printf("入边 , y is %d ,left is %d,right is %d
",b[i].y1,b[i].x1,b[i].x2 );
        } 
       else
        {
            printf("出边 , y is %d ,left is %d,right is %d
",b[i].y2,b[i].x1,b[i].x2 );
        }
    }
}

ll sall;  //总面积 


ll slove1()
{
   ll res = 0;
   sort(a,a+size,cmp1);
   int cur = 1;
   updata(a[0].y1,a[0].y2,1,1);
   while(cur < size)
    {
       int dis = a[cur].getx() - a[cur-1].getx();
       res += (ll)dis*(ll)tree[1].sum;
       if (a[cur].flag & 1) //出边 
        updata(a[cur].y1,a[cur].y2,-1,1);
       else
        updata(a[cur].y1,a[cur].y2,1,1); 
       cur++;
    } 
   return sall - res;
}


ll slove2()
{
   ll res = 0;
   sort(b,b+size,cmp2);
   int cur = 1;
   updata(b[0].x1,b[0].x2,1,1);
   while(cur < size)
    {
       int dis = b[cur].gety() - b[cur-1].gety();
       res += (ll)dis*(ll)tree[1].sum;
       if (b[cur].flag & 1) //出边 
        updata(b[cur].x1,b[cur].x2,-1,1);
       else
        updata(b[cur].x1,b[cur].x2,1,1);
       cur++;
    } 
   return sall - res;
}

int main(int argc,char *argv[])
{
  scanf("%d%d%d%d",&w,&h,&n,&m);
  memset(tree,0,sizeof(tree));
  memset(a,0,sizeof(a));
  memset(b,0,sizeof(b));
  build_tree(1,0,max(w,h)+4); // Build Tree
  sall = (ll)w*(ll)h;
  for(int i = 0 ; i < n ; ++ i)
   {
         int x1,y1,x2,y2,oriy1,orix1;
         scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
         x1 -- , y1 -- ; //转换为线段式 
         orix1 = x1,oriy1 = y1;
         x1 = x1-m+1 >= 0 ? x1-m+1 : 0;
         y1 = y1-m+1 >= 0 ? y1-m+1 : 0;
         a[size].x1 = x1,a[size].x2 = x2,a[size].y1 = oriy1 , a[size].y2 = y2 , a[size].flag = 0;
         b[size].x1 = orix1 , b[size].x2 = x2 , b[size].y1 = y1,b[size].y2 = y2 , b[size++].flag = 0;
         a[size].x1 = x1,a[size].x2 = x2,a[size].y1 = oriy1 , a[size].y2 = y2 , a[size].flag = 1;
         b[size].x1 = orix1 , b[size].x2 = x2 , b[size].y1 = y1,b[size].y2 = y2 , b[size++].flag = 1;
   }
  ll ans = 0;
  a[size].x1 = w-m + 1 >= 0 ? w-m+1 : 0 , a[size].x2 = w , a[size].y1 = 0 , a[size].y2 = h,a[size++].flag = 0;  //添加限制线  
  a[size].x1 = w-m + 1 >= 0 ? w-m+1 : 0 , a[size].x2 = w , a[size].y1 = 0 , a[size].y2 = h,a[size++].flag = 1;
  ans += slove1();
  size -= 2;
  b[size].x1 = 0,b[size].x2 = w ,b[size].y1 = h-m+1 >= 0 ? h-m+1 : 0,b[size].y2 = h , b[size++].flag = 0;
  b[size].x1 = 0,b[size].x2 = w ,b[size].y1 = h-m+1 >= 0 ? h-m+1 : 0,b[size].y2 = h , b[size++].flag = 1;
  ans += slove2();
  if (m == 1)
   printf("%lld
",ans/2);
  else
   printf("%lld
",ans);
  return 0;
}