HDU 4444 Walk (离散化建图+BFS+记忆化搜索) 绝对经典

题目地址：http://acm.hdu.edu.cn/showproblem.php?pid=4444

题意：给你一些n个矩形，给你一个起点，一个终点，要你求从起点到终点最少需要转多少个弯

题解：因为矩形数量很少50个，可以离散化成102*102的坐标，但是人可以贴着墙壁走，但不能穿过墙壁

所以每个点要分成9等分。建筑物的边占1/3，但是这样有漏洞。

1、当两个墙壁贴在一起，中间还可以过，所以要填补中间

2、当两个矩形的角重合，中间也可以过，要填补中间，但是只能填补中间一个点，不能填补全部的9个点。

还有一点要注意的是，起点有多个，终点也有多个，从任意一起点到任意一终点即可，因为有一些特殊数据，我的例子里面有

图建好了，直接BFS记忆化搜索即可。

AC代码：

 

#include <iostream>

#include <cstdio>

#include <cstring>

#include <string>

#include <cstdlib>

#include <cmath>

#include <vector>

#include <list>

#include <deque>

#include <queue>

#include <iterator>

#include <stack>

#include <map>

#include <set>

#include <algorithm>

#include <cctype>

#include <sstream>

using namespace std;



typedef long long LL;

const int N=410;

const LL II=100000000;

const int INF=0x3f3f3f3f;

const int M=12345678;

const double PI=acos(-1.0);



int sx,sy,ex,ey;

int si,sj,ei,ej;

int n,nx,ny;

int x[N],y[N];

int g[N][N],step[N][N];

int t[4][2]={1,0,-1,0,0,1,0,-1};



struct node

{

    int x1,x2,y1,y2;

}rect[N];



struct xiaohao

{

    int xx,yy;

    int step;

}e,w,xh[M];



int nextint()

{

    int f=1;

    char c;

    while((c=getchar())<'0'||c>'9')

        if(c=='-')

            f=-1;

    int sum=c-'0';

    while((c=getchar())>='0'&&c<='9')

        sum=sum*10+c-'0';

    return sum*f;

}



void lisanhua(int m) //离散化

{

    int i,j;

    sort(x+1,x+m+1);

    sort(y+1,y+m+1);

    nx=1;

    for(i=2;i<=m;i++)//去重

        if(x[i]!=x[i-1])

            x[++nx]=x[i];

    ny=1;

    for(i=2;i<=m;i++)//去重

        if(y[i]!=y[i-1])

            y[++ny]=y[i];

}



int getx(int xx)//数据量大的时候可以用二分查找

{

    for(int i=1;i<=nx;i++)

        if(x[i]==xx)

            return i;

}



int gety(int yy)

{

    for(int i=1;i<=ny;i++)

        if(y[i]==yy)

            return i;

}



void add(int x1,int x2,int y1,int y2)

{

    int i,j;

    for(i=x1;i<=x2;i++)

        for(j=y1;j<=y2;j++)

            g[i][j]=1;//建筑物标记为1

}



void jiantu()

{

    int i,j,x1,x2,y1,y2;

    memset(g,0,sizeof(g));

    si=getx(sx);

    sj=gety(sy);

    ei=getx(ex);

    ej=gety(ey);



    for(i=si*3;i>=si*3-2;i--)//起点,这个地方9个格子全部要标记为5

        for(j=sj*3;j>=sj*3-2;j--)

            g[i][j]=5;

    for(i=ei*3;i>=ei*3-2;i--)//终点,这个地方9个格子全部要标记为6

        for(j=ej*3;j>=ej*3-2;j--)

            g[i][j]=6;



    for(i=1;i<=n;i++)

    {

        x1=getx(rect[i].x1);

        y1=gety(rect[i].y1);

        x2=getx(rect[i].x2);

        y2=gety(rect[i].y2);



        add(x1*3,x2*3-2,y1*3,y2*3-2);

    }

    for(i=1;i<=nx;i++)//将重合的点中间补上

        for(j=1;j<=ny;j++)

        {

            if(g[i*3-2][j*3-2]==1&&g[i*3][j*3]==1||g[i*3-2][j*3]==1&&g[i*3][j*3-2]==1)

                g[i*3-1][j*3-1]=1;

            if(g[i*3-1][j*3-2]==1&&g[i*3-1][j*3]==1)

                g[i*3-1][j*3-1]=1;

            if(g[i*3-2][j*3-1]==1&&g[i*3][j*3-1]==1)

                g[i*3-1][j*3-1]=1;

        }

//    for(i=1;i<=3*nx;i++) //输出离散化后的图

//    {

//        for(j=1;j<=3*ny;j++)

//            printf("%d",g[i][j]);

//        printf("\n");

//    }

}



bool ok(int tx,int ty)

{

    return (tx>=0&&tx<=3*nx&&ty>=0&&ty<=3*ny);

}



void BFS()

{

    int i,j,head=0,tail=0;

    w.step=-1;

    for(i=si*3;i>=si*3-2;i--)

        for(j=sj*3;j>=sj*3-2;j--)

            if(g[i][j]==5)

            {

                w.xx=i;w.yy=j;

                xh[tail++]=w;

            }

    memset(step,INF,sizeof(step));

    step[w.xx][w.yy]=-1;

    while(head!=tail)

    {

        e=xh[head++];

        if(head==M)

            head=0;

        for(i=0;i<4;i++)

        {

            w=e;

            w.step++;

            int tx=w.xx+t[i][0];

            int ty=w.yy+t[i][1];

            while(ok(tx,ty)&&g[tx][ty]!=1)//判断是否在界内，而且能走

            {

                if(w.step<step[tx][ty])

                {

                    if(g[tx][ty]==6)

                    {

                        printf("%d\n",w.step);

                        return ;

                    }

                    step[tx][ty]=w.step;

                    w.xx=tx;

                    w.yy=ty;

                    xh[tail++]=w;

                    if(tail==M)

                        tail=0;

                }

                tx+=t[i][0];

                ty+=t[i][1];

            }

        }

    }

    printf("-1\n");

}



int main()

{

    int i,j;

    while(scanf("%d%d%d%d",&sx,&sy,&ex,&ey))

    {

        int x1,x2,y1,y2,m;

        if((!sx)&&(!sy)&&(!ex)&&(!ey))

            break;

        if(sx==ex&&sy==ey)

        {

            printf("0\n");

            continue;

        }

        m=0;

        rect[0].x1=x[++m]=sx;

        rect[0].y1=y[m]=sy;

        rect[0].x2=x[++m]=ex;

        rect[0].y2=y[m]=ey;

        scanf("%d",&n);

        for(i=1;i<=n;i++)

        {

            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);

            if(x1>x2)//防止有的数据先是右上点再是左下点

                swap(x1,x2),swap(y1,y2);



            x[++m]=rect[i].x1=x1;

            y[m]=rect[i].y1=y1;

            x[++m]=rect[i].x2=x2;

            y[m]=rect[i].y2=y2;

        }



        lisanhua(m);

        jiantu();

        BFS();

    }

    return 0;

}



/*

0 0 3 3

4

2 0 4 2

0 2 2 4

4 2 6 4

2 4 4 6



100 -50 10 20

4

-100 15 -20 30

-5 25 50 100

-30 -30 70 -20

70 -20 120 80



5 -1 60 7

3

1 8 101 888

0 0 49 5

50 0 100 6



0 -1 2 1

3

-1 0 0 1

0 1 1 2

1 -2 3 0



0 0 0 10

1

0 5 5 8



0 0 0 10

1

-3 5 0 8



0 0 0 10

2

0 5 5 8

0 2 4 5



0 0 0 10

2

0 5 5 8

-2 1 0 4



0 0 0 10

2

0 0 5 8

-2 1 0 5



0 0 1 10

0



0 -1 2 1

3

-1 0 0 1

0 1 1 2

1 -2 3 0



0 -1 -1 0

9

-3 4 4 5

4 -3 5 5

-2 -3 4 -2

-3 -3 -2 4

-1 2 0 4

1 1 3 3

0 0 1 1

-2 -2 0 0

2 -2 3 0



0 0 0 0





结果应该为：

-1

3

2

1

0

0

0

0

2

1

1

5

*/