codeforce-243C:Colorado Potato Beetle（BFS+离散化+暴力）

题目链接：点击打开链接

题目大意：

题目是真的长，我的天，像我这种四级都过不了的渣渣怎么看的懂嘛！！！言归正传，题目大意是有一个你可以理解为无穷大的田地，你身在中心，然后你可以选择向上下左右四个方向走任意步，走过的田地算做被洒过农药，等你走完之后会有虫子来侵蚀你的田地，最后问你田地里没被侵蚀的地方有多大。虫子会从农场外围开始侵蚀，并且可以从被侵蚀的田地的上下左右再次侵蚀。注意是上下左右，所以斜的地方虫子进不去。

解题思路：

这道题刚拿到手，完全不懂什么意思，查题意的时候就顺带看到了解法，然而看到了还是不会做啊！！！  主要应用离散化+bfs暴力。主要我离散化是完全不会写，就很tm尴尬，之前就做过一道扫描线用过一次。这次做这道题感觉深刻理解了离散化的思想。

简单说一下离散化，离散化就是将某段区间具象化为一个点，例如，1到5,5到7,7到10。离散化后可以理解为只有两个点，每个点有个左右端点，第一个点左端点为1，右端点为5，以此类推，具象化到程序里面呢就是 x[i+1]-x[i]，要用的时候二分找下标，还是很好理解的，离散化的目的嘛，你看这道题，田地无穷大（其实也不是无穷大），农夫一步走辣么远，怎么存。你告诉我怎么存，有了离散化就方便了。

离散化之后呢，就是下一步，我们需要一个数组存当前田地的状态，有三种状态，分别是什么操作也没有的，被撒了农药的，被害虫侵蚀的。bfs模拟害虫侵蚀的过程，然后暴力求出没有被侵蚀的田地的面积就ok了。代码部分还有很多细节，代码里详解。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
#include <set>
#include <functional>
using namespace std;
typedef long long ll;
typedef unsigned long long Ull;
int n,m,k1,k2;
ll ans;
int dx[4]={-1,0,1,0};   //方向数组
int dy[4]={0,-1,0,1};
ll x[2005];     //离散化数组，要用long long，不然就wa，别问我怎么知道的
ll y[2005];
int vis[2005][2005];    //标记数组
struct node         //记录农夫洒过农药的地方
{
    ll x1,x2,y1,y2;
}t[2005];
struct dog
{
    int x,y;
};
int vs(char c)
{
    if(c=='U')
        return 0;
    if(c=='L')
        return 1;
    if(c=='D')
        return 2;
    return 3;
}
int bin(ll key,int g,ll d[])    //离散化中二分查找下标
{
    int l=1,r=g;
    int mid=(l+r)>>1;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(d[mid]==key)
            return mid;
        else if(d[mid]<key)
            l=mid+1;
        else
            r=mid-1;
    }
    return -1;
}
void bfs()      //害虫侵蚀过程简单bfs
{
    queue<dog> que;
    dog st;
    st.x=0;st.y=0;
    vis[0][0]=2;
    que.push(st);
    while(!que.empty())
    {
        dog k=que.front();
        que.pop();
        for(int i=0;i<4;i++)
        {
            int xx=k.x+dx[i];
            int yy=k.y+dy[i];
            dog kk;
            if(xx>=0&&xx<=k1&&yy>=0&&yy<=k2&&vis[xx][yy]==0)
            {
                kk.x=xx;
                kk.y=yy;
                vis[xx][yy]=2;
                que.push(kk);
            }
        }
    }
}
int main()
{
    int x1,y1,x2,y2;
    while(scanf("%d",&n)!=EOF)
    {
        memset(vis,0,sizeof(vis));
        x1=0;
        y1=0;
        int g=0,p,kk=0;
        char c;
        for(int i=0;i<n;i++)
        {
            scanf(" %c %d",&c,&p);
            x2=x1+dx[vs(c)]*p;
            y2=y1+dy[vs(c)]*p;
            x[++g]=min(x1,x2);          //这里注意要判断大小，刚开始默认按顺序赋值x1,x2,样例都过不了
            y[g]=min(y1,y2);
            x[++g]=max(x1,x2)+1;        //这里的+1可以自己想一下为什么
            y[g]=max(y1,y2)+1;
            t[++kk].x1=min(x1,x2);t[kk].x2=max(x1,x2)+1;
            t[kk].y1=min(y1,y2);t[kk].y2=max(y1,y2)+1;
            x1=x2;y1=y2;
        }
        sort(x+1,x+1+g);        //对x,y数组排序去重
        sort(y+1,y+1+g);
        k1=1;
        for(int i=2;i<=g;i++)       //去重操作
        {
            if(x[i]!=x[i-1])
                x[++k1]=x[i];
        }
        k2=1;
        for(int i=2;i<=g;i++)
        {
            if(y[i]!=y[i-1])
                y[++k2]=y[i];
        }
        int p1,p2,q1,q2;
        for(int k=1;k<=kk;k++)      //将农夫走过的路打上标记
        {
            p1=bin(t[k].x1,k1,x);
            p2=bin(t[k].x2,k1,x)-1; //这里的减1也是要注意的地方
            q1=bin(t[k].y1,k2,y);
            q2=bin(t[k].y2,k2,y)-1;
            if(p2<p1) p2=p1;
            if(q2<q1) q2=q1;
            for(int i=p1;i<=p2;i++)
            {
                for(int j=q1;j<=q2;j++)
                    vis[i][j]=1;
            }
        }
        bfs();
        ans=0;
        for(int i=0;i<=k1;i++)      //暴力求出未被侵蚀的田地
        {
            for(int j=0;j<=k2;j++)
            {
                if(vis[i][j]!=2)
                    ans=ans+(x[i+1]-x[i])*(y[j+1]-y[j]);
            }
        }
        printf("%I64d\n",ans);
    }
}