Codeforces243C-Colorado Potato Beetle(离散化+bfs)

Old MacDonald has a farm and a large potato field, (10¹⁰ + 1) × (10¹⁰ + 1) square meters in size. The field is divided into square garden beds, each bed takes up one square meter.

Old McDonald knows that the Colorado potato beetle is about to invade his farm and can destroy the entire harvest. To fight the insects, Old McDonald wants to spray some beds with insecticides.

So Old McDonald went to the field, stood at the center of the central field bed and sprayed this bed with insecticides. Now he's going to make a series of movements and spray a few more beds. During each movement Old McDonald moves left, right, up or down the field some integer number of meters. As Old McDonald moves, he sprays all the beds he steps on. In other words, the beds that have any intersection at all with Old McDonald's trajectory, are sprayed with insecticides.

When Old McDonald finished spraying, he wrote out all his movements on a piece of paper. Now he wants to know how many beds won't be infected after the invasion of the Colorado beetles.

It is known that the invasion of the Colorado beetles goes as follows. First some bed on the field border gets infected. Than any bed that hasn't been infected, hasn't been sprayed with insecticides and has a common side with an infected bed, gets infected as well. Help Old McDonald and determine the number of beds that won't be infected by the Colorado potato beetle.

Input

The first line contains an integer n (1 ≤ n ≤ 1000) — the number of Old McDonald's movements.

Next n lines contain the description of Old McDonald's movements. The i-th of these lines describes the i-th movement. Each movement is given in the format "d_ix_i", where d_i is the character that determines the direction of the movement ("L", "R", "U" or "D" for directions "left", "right", "up" and "down", correspondingly), and x_i (1 ≤ x_i ≤ 10⁶) is an integer that determines the number of meters in the movement.

Output

Print a single integer — the number of beds that won't be infected by the Colorado potato beetle.

Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64dspecifier.

Sample Input

Input

5 
R 8 
U 9 
L 9 
D 8 
L 2

Output

101

Input

7 
R 10 
D 2 
L 7 
U 9 
D 2 
R 3 
D 10

Output

52

题意：有一个非常大的田地（你当它是无穷大的），每一格大小是1m*1m,主人公要喷杀虫剂，他从起点开始，可以朝U(上),D(下),L(左),R(右)四个方向走一段距离，则这段路上的格子都被喷了杀虫剂，
给出N次操作，每次输入一个字符和数字，分别代表方向和路程。害虫入侵田地的方式是从外围入侵，如果某个相邻的格子没有被喷杀虫剂则可以蔓延。最后要求出剩下没被入侵的总面积。

解析：田地太大，面积太大，直接搜是不可能的，但是N最大只有1000，那么可以考虑把x坐标y坐标离散化，点最多也就上千，这里有一个技巧，就是离散化后的点扩大两倍，为了后面方便bfs，所以我把
最外围扩了一圈，那么离散的坐标就是1,3,5.....2*k+1。 0和2*k+2是外围。我把整个图压缩成了一维，比如（x,y）对应的下标就是x*列宽+y,接下来就是bfs，先把走过的地方全部标记为1，其他地方
标记为-1，此时我只需要把（0,0）加入队列搜即可（你可以仔细想一下为什么），把能够走的地方全部标记为0。但是要注意一点，因为我是扩大了两倍，如果当前搜的方向是上或下，且这个点的y坐标是偶数
（不是边界），需要判断一下离散化的左右两个数的差值是否为1，是的话是不能走的（被堵死了），因为这个点本就是虚拟的点。如果当前搜的方向是左或右，x坐标是偶数（不是边界）同理。最后就是计算总
面积，如果这个点不是标记为0（不能被害虫入侵），则判断它的x,y坐标的奇偶性，x,y同时为奇数则加1，x为偶数，则加x轴方向的距离-1，y为偶数，则加y轴方向的距离-1，都是偶数则加两个方向的距离-1
的乘积。（注意会爆int）
代码

#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<utility>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<iterator>
#include<stack>
using namespace std;
typedef __int64 LL;
const int INF=1e9+;
const double eps=1e-;
const int maxn=;
int M,wx[maxn],wy[maxn];
int tempx[maxn],tempy[maxn],row,col;
int dx[]={-,,,},dy[]={,-,,};
int maze[];
bool in(int x,int y){ return x>=&&x<row*+&&y>=&&y<col*+; }//是否在界内
int GetId(int x,int y){ return x*(col*+)+y; }
void Print(int A[],int N)
{
    for(int i=;i<=N;i++) printf("%d ",A[i]);
    puts("");
}
void init()
{
    for(int i=;i<=M;i++) tempx[i]=wx[i],tempy[i]=wy[i];
    sort(tempx,tempx+M+);     //下面是离散化过程
    sort(tempy,tempy+M+);
    row=col=;
    for(int i=;i<=M;i++) if(tempx[i]!=tempx[row]) tempx[++row]=tempx[i]; //去重
    for(int i=;i<=M;i++) if(tempy[i]!=tempy[col]) tempy[++col]=tempy[i];
}
struct node
{
    int x,y;
    node(int x=,int y=):x(x),y(y){}
};
queue<node> que;
void bfs()
{
    memset(maze,-,sizeof(maze));
    for(int i=;i<=M;i++)
    {
        int x1=lower_bound(tempx,tempx+row+,wx[i-])-tempx;  //找对应离散化后的值
        int y1=lower_bound(tempy,tempy+col+,wy[i-])-tempy;
        int x2=lower_bound(tempx,tempx+row+,wx[i])-tempx;
        int y2=lower_bound(tempy,tempy+col+,wy[i])-tempy;
        x1=x1*+; y1=y1*+; x2=x2*+; y2=y2*+;  //扩大
        if(x1==x2)
        {
            if(y1>y2) swap(y1,y2);
            for(int st=y1;st<=y2;st++) maze[GetId(x1,st)]=;  //做标记
        }
        else if(y1==y2)   //同理
        {
            if(x1>x2) swap(x1,x2);
            for(int st=x1;st<=x2;st++) maze[GetId(st,y1)]=;
        }
    }
    while(!que.empty()) que.pop();
    que.push(node(,));  //把（0,0）丢进队列
    maze[GetId(,)]=;
    while(!que.empty())
    {
        node& t=que.front();  que.pop();
        int x=t.x,y=t.y;
        for(int i=;i<;i++)
        {
            int nx=x+dx[i];
            int ny=y+dy[i];
            if(!in(nx,ny)) continue; //出界不管
            int id=GetId(nx,ny);
            if(ny%==&&(i==||i==)&&in(nx,ny-)&&in(nx,ny+))//y坐标为偶数且方向是上下，不是外围
            {
                int a=(ny-)/;
                int b=(ny+)/;
                if(tempy[b]-tempy[a]-<=) continue;  //值差为1不能走
            }
            if(nx%==&&(i==||i==)&&in(nx-,ny)&&in(nx+,ny)) //同理
            {
                int a=(nx-)/;
                int b=(nx+)/;
                if(tempx[b]-tempx[a]-<=) continue;
            }
            if(maze[id]==-){ que.push(node(nx,ny)); maze[id]=; }  //标记为0
        }
    }
}
LL solve()
{
    LL ret=;
    bfs();
    for(int i=;i<row*+;i++)
        for(int j=;j<col*+;j++)
    {
        int p=GetId(i,j);
        if(maze[p]==) continue;
        int a=(j+)/,b=(j-)/;
        int c=(i+)/,d=(i-)/;
        if(i%==&&j%==) ret++;  //都是奇数
        else if(i%==) ret+=(LL)tempy[a]-tempy[b]-; //x坐标为奇数，y坐标为偶数
        else if(j%==) ret+=(LL)tempx[c]-tempx[d]-; //y坐标为奇数，x坐标为偶数
        else ret+=(LL)(tempx[c]-tempx[d]-)*(tempy[a]-tempy[b]-); //均为偶数
    }
    return ret;
}
int main()
{
    while(scanf("%d",&M)!=EOF)
    {
        wx[]=,wy[]=;
        for(int i=;i<=M;i++)
        {
            char c;
            int d;
            scanf(" %c %d",&c,&d);
            wx[i]=wx[i-]; wy[i]=wy[i-];
            if(c=='U') wx[i]-=d;
            else if(c=='D') wx[i]+=d;
            else if(c=='L') wy[i]-=d;
            else if(c=='R') wy[i]+=d;
            //printf("%d %d\n",wx[i],wy[i]);
        }
        init();
        printf("%I64d\n",solve());
    }
    return ;
}