【bfs+优先队列】POJ2049-Finding Nemo

基本上算是普通但略有些繁琐的广搜。给出的墙面和门的坐标为点，而Nemo位于方格中。

【思路】

首先思考一下如何存储下整个坐标系。我们预先约定，用一个方格的左下角顶点坐标来作为这个方格的坐标。map[i][j][k]数组是一个三维数组，下标前两位表示当前方格坐标为(i,j)，第三位依次表示方格的上下左右，对应下标中的元素用0表示空白，1表示有墙，2表示有门。读入数据的时候，同时修改该墙或门两侧的方格。注意dx、dy数组一定要与上下左右的方向对应，方便后续操作。最后读入Nemo的坐标只要去尾法强制取整即可。但是看别人讨论，强制取整不能用(int)，否则会WA，我试了一下的确会有这种问题。用floor会直接将float赋给int可以解决问题。

广搜时从Nemo开始倒退，由于我们需要比较的是经过最小的门数，而不是走的最小步数，广搜的队列必须要用优先队列存储。

【剪枝】

当没有任何一道门或墙的时候，即m=n=0时，直接输出0；

当Nemo在迷宫最大范围外，即fx>199||fy>199||fx<0||fy<0，直接输出0；

读入数据时记录下门或墙纵坐标的最大最小值，最小值为起点减1，最大值为起点加上长度。当前坐标中某一位大于这个极值时，可以直接走到终点，直接输出此时的步数；

（和上一步略有重复）当前坐标大于门或墙横纵坐标最大值时，只会越走越远，所以可以制止搜索继续。但不能把(nowx<0 || nowy<0 || nowx>limitx || nowy>limity) 写成(nowx<littlex || nowy<littley || nowx>limitx || nowy>limity)，因为Nemo倒推时总是越来越趋向于(0,0)点，这么判断会使得大多数情形都变成无解。

 #include<queue>
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 const int MAXN=;
 const int INF=;
 struct point
 {
     int x,y,num;
     bool operator < (const point &x) const
     {
         return num>x.num;
         /*优先队列设置为小顶堆*/
     }
 };
 int m,n;
 int limitx,limity,littlex,littley,fx,fy;
 int map[MAXN][MAXN][];
 int step[MAXN][MAXN];
 /*方格的坐标用左下角顶点坐标来记录*/
 /*第三维依次代表上下左右*/
 /*数组内元素的值0：空白 1：墙 2：门*/
 int dx[]={,,-,};
 int dy[]={,-,,};
 /*d数组要对应上下左右的顺序，方便后续操作*/
 int vis[MAXN][MAXN];
 float initx,inity;

 void initwall()
 {
     memset(map,,sizeof(map));
     limitx=limity=-;
     littlex=littley=INF;
     int x,y,d,t;
     for (int i=;i<m;i++)
     {
         cin>>x>>y>>d>>t;
         if (x+t>limitx) limitx=x+t;
         if (y+t>limity) limity=y+t;
         if (x-<littlex) littlex=x-;
         if (y-<littley) littley=y-;
         if (d==)
         {
           for (int j=x;j<x+t;j++)
           {
               map[j][y][]=;
               if (y>=) map[j][y-][]=;
           }
         }
         else
         {
             for (int j=y;j<y+t;j++)
             {
                 map[x][j][]=;
                 if (x>=) map[x-][j][]=;
             }
         }
     }
 }

 void initdoor()
 {
     int x,y;
     int d;
     for (int i=;i<n;i++)
     {
         scanf("%d%d%d",&x,&y,&d);
         if (x+>limitx) limitx=x+;
         if (y+>limity) limity=y+;
         if (x-<littlex) littlex=x-;
         if (y-<littley) littley=y-;
         if (d==)
         {
                 map[x][y][]=;
                 if (y>=) map[x][y-][]=;
         }
         else
         {
                 map[x][y][]=;
                 if (x>=) map[x-][y][]=;
         }
     }
 }

 int bfs()
 {
     for (int i=;i<=limitx;i++)
         for (int j=;j<=limity;j++) step[i][j]=INF;
     int ans=INF;
     point in,out;
     memset(vis,,sizeof(vis));
     step[fx][fy]=;
     in.x=fx;in.y=fy;in.num=;
     priority_queue<point> que;
     /*由于队列记录的是经过的门数而非步数，要用优先队列*/
     que.push(in);
     while (!que.empty())
     {
         out=que.top();
         que.pop();
         if (out.x== && out.y==|| out.x==littlex || out.y==littley || out.x==limitx || out.y==limity)
         {
             return out.num;
         }
             /*如果到达终点或超出最大范围，直接输出结果*/
         for (int i=;i<;i++)
         {
             int nowx=out.x+dx[i],nowy=out.y+dy[i],nownum=out.num;
             if (nowx< || nowy< || nowx>limitx || nowy>limity) continue;
             if (map[out.x][out.y][i]==) continue;
             /*前进的方向不能被门阻隔*/
             if (map[out.x][out.y][i]==) nownum++;
             /*如果前进的方向是一扇门，则加一*/
             if (step[nowx][nowy]==INF || nownum<step[nowx][nowy]&& nownum<ans)
             {
                 in.x=nowx;in.y=nowy;in.num=nownum;
                 que.push(in);
                 step[nowx][nowy]=in.num;
             }
         }
     }
     return -;
     /*无解时返回-1*/
 }

 int main()
 {
     while (scanf("%d%d",&m,&n))
     {
         if (m==n && m==-) break;

         initwall();
         initdoor();
         cin>>initx>>inity;
         fx=initx;
         fy=inity;
         /*由于方格坐标由左下角定点来表示，强制转换为int型即可*/
         if (n== && m==||fx>||fy>||fx<||fy<)
            cout<<<<endl;
         else cout<<bfs()<<endl;
     }
     return ;
 }