hdu 4444 Walk(离散化+BFS)

题目链接：hdu 4444 Walk

题意：

有n个矩形，现在biaoge要从一个点走到另外一个点上，不能穿过矩形，但可以沿着边走。

问最少需要多少次转弯才能到达。

题解：

由于数据很大，需要离散化一下，然后就是一个bfs，用三维的vis来记录最好的状态。

细节比较多，需要考虑延边走时的拐角方向。

#include<bits/stdc++.h>
#define mst(a,b) memset(a,b,sizeof(a))
#define F(i,a,b) for(int i=(a);i<=(b);++i)
using namespace std;
typedef pair<int,int>P;

const int N=507,inf=1e9,all=1e8+7;
int mp[N][N],st[2],en[2],vis[4][N][N];
int hshx[N],hshy[N],hx_ed,hy_ed;
int n,NN,MM,dir[][2]={1,0,0,1,-1,0,0,-1};
vector<int>X,Y;
struct SQR
{
    P point[2];
    void in(int a,int b,int c,int d)
    {
        point[0].first=min(a,c);
        point[0].second=min(b,d);
        point[1].first=max(a,c);
        point[1].second=max(b,d);
    }
    void get()
    {
        point[0].first=lower_bound(X.begin(),X.end(),point[0].first)-X.begin()+1;
        point[1].first=lower_bound(X.begin(),X.end(),point[1].first)-X.begin()+1;
        point[0].second=lower_bound(Y.begin(),Y.end(),point[0].second)-Y.begin()+1;
        point[1].second=lower_bound(Y.begin(),Y.end(),point[1].second)-Y.begin()+1;
    }
}sqr[100];

struct Node
{
    int x,y,turn,d;
    Node(int a=0,int b=0,int c=0,int d_=0):x(a),y(b),turn(c),d(d_){}
};

int check(int x,int y,int prex,int prey,int i,int prei)
{
    if(x<1||x>NN||y<1||y>MM)return 0;
    if(mp[x][y]==1)
    {
        if((mp[x][y+1]==2&&mp[x][y-1]==2)||
          (mp[x+1][y]==2&&mp[x-1][y]==2))return 0;
        if((mp[x-1][y-1]==2&&mp[x+1][y+1]==2))
        {
            if(prei==0&&i!=1)return 0;
            if(prei==3&&i!=2)return 0;
            if(prei==1&&i!=0)return 0;
            if(prei==2&&i!=3)return 0;
        }
        if((mp[x-1][y+1]==2&&mp[x+1][y-1]==2))
        {
            if(prei==0&&i!=3)return 0;
            if(prei==3&&i!=0)return 0;
            if(prei==1&&i!=2)return 0;
            if(prei==2&&i!=1)return 0;
        }
    }

    return 1;
}

int bfs()
{
    queue<Node>Q;
    F(k,0,3)F(i,0,NN+1)F(j,0,MM+1)vis[k][i][j]=inf;
    F(k,0,3)vis[k][st[0]][st[1]]=0;
    Q.push(Node(st[0],st[1],0,-1));
    while(!Q.empty())
    {
        Node now=Q.front();Q.pop();
        if(now.d!=-1&&now.turn>vis[now.d][now.x][now.y])continue;
        if(now.x==en[0]&&now.y==en[1])continue;
        F(i,0,3)
        {
            int tx=now.x+dir[i][0],ty=now.y+dir[i][1];
            int tturn=now.turn;
            if(now.d!=-1&&now.d!=i)tturn++;
            if(!check(now.x,now.y,tx,ty,i,now.d)||vis[i][tx][ty]<=tturn||mp[tx][ty]>1)continue;
            Q.push(Node(tx,ty,tturn,i));
            vis[i][tx][ty]=tturn;
        }
    }
    int ans=inf;
    F(i,0,3)ans=min(ans,vis[i][en[0]][en[1]]);
    return ans;
}

int main()
{
    while(scanf("%d%d%d%d",st,st+1,en,en+1),st[0]||st[1]||en[1]||en[0])
    {
        st[0]+=all,st[1]+=all,en[0]+=all,en[1]+=all;
        st[0]*=2,st[1]*=2,en[0]*=2,en[1]*=2;
        hshx[hx_ed=1]=st[0];hshx[++hx_ed]=en[0];
        hshy[hy_ed=1]=st[1];hshy[++hy_ed]=en[1];
        scanf("%d",&n);
        X.clear(),Y.clear();
        F(i,1,n)
        {
            int a,b,c,d;
            scanf("%d%d%d%d",&a,&b,&c,&d);
            a+=all,b+=all,c+=all,d+=all;
            a*=2,b*=2,c*=2,d*=2;
            sqr[i].in(a,b,c,d);
            hshx[++hx_ed]=a,hshx[++hx_ed]=c;
            hshy[++hy_ed]=b,hshy[++hy_ed]=d;
        }
        sort(hshx+1,hshx+1+hx_ed),hx_ed=unique(hshx+1,hshx+1+hx_ed)-hshx-1;
        sort(hshy+1,hshy+1+hy_ed),hy_ed=unique(hshy+1,hshy+1+hy_ed)-hshy-1;
        X.push_back(-inf),X.push_back(hshx[1]);
        F(i,2,hx_ed)
        {
            if(hshx[i]>hshx[i-1]+1)X.push_back(hshx[i-1]+1);
            X.push_back(hshx[i]);
        }
        X.push_back(inf);
        Y.push_back(-inf),Y.push_back(hshy[1]);
        F(i,2,hy_ed)
        {
            if(hshy[i]>hshy[i-1]+1)Y.push_back(hshy[i-1]+1);
            Y.push_back(hshy[i]);
        }
        Y.push_back(inf);
        F(i,1,n)sqr[i].get();
        st[0]=lower_bound(X.begin(),X.end(),st[0])-X.begin()+1;
        st[1]=lower_bound(Y.begin(),Y.end(),st[1])-Y.begin()+1;
        en[0]=lower_bound(X.begin(),X.end(),en[0])-X.begin()+1;
        en[1]=lower_bound(Y.begin(),Y.end(),en[1])-Y.begin()+1;
        NN=X.size(),MM=Y.size();
        F(i,0,NN+1)F(j,0,MM+1)mp[i][j]=0;
        F(i,1,n)
        {
            int x1=sqr[i].point[0].first,x2=sqr[i].point[1].first;
            int y1=sqr[i].point[0].second,y2=sqr[i].point[1].second;
            F(j,x1+1,x2-1)F(k,y1+1,y2-1)mp[j][k]=2;
            F(j,x1,x2)F(k,y1,y2)if(mp[j][k]==0)mp[j][k]=1;
        }
        int ans=bfs();
        printf("%d
",ans==inf?-1:ans);
    }
    return 0;
}