POJ:2935 Basic Wall Maze

还是典型的BFS。只加了一些限制条件而已。每道墙可以转化为从某格不能移动到某格。

最后要求打印出路径，用一个数组保存路径，递归实现打印。

虽然是1Y却憋了挺长时间，还是说明了我很水。。

 

 

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
bool vis[10][10];
bool sp[10][10][10][10];
struct Grid
{
    int x,y;
    Grid(int a=0,int b=0):x(a),y(b) {}
    bool operator== (Grid &t)
    {
        if(x==t.x&&y==t.y) return true;
        return false;
    }
};
bool Judge(int x,int y)
{
    if(1<=x&&x<=6&&1<=y&&y<=6) return true;
    return false;
}
int m[4][2]= {{1,0},{-1,0},{0,1},{0,-1}};
int dir[10][10];
Grid last_grid[10][10];
void Print(Grid p,Grid st)
{
    if(p==st) return ;
    Print(last_grid[p.x][p.y],st);
    if(dir[p.x][p.y]==0) putchar('S');
    else if(dir[p.x][p.y]==1) putchar('N');
    else if(dir[p.x][p.y]==2) putchar('E');
    else if(dir[p.x][p.y]==3) putchar('W');
}
int main()
{
    int sx,sy;
    while(scanf("%d%d",&sx,&sy)&&!(!sx&&!sy))
    {
        int ex,ey;
        scanf("%d%d",&ex,&ey);
        memset(sp,0,sizeof(sp));
        for(int i=0; i<3; ++i)
        {
            int ax,ay,bx,by;
            scanf("%d%d%d%d",&ax,&ay,&bx,&by);
            if(ax==bx)
            {
                int mn=min(ay,by),mx=max(ay,by);
                for(int j=mn+1; j<=mx; ++j)
                    sp[j][ax][j][ax+1]=sp[j][ax+1][j][ax]=true;

            }
            else if(ay==by)
            {
                int mn=min(ax,bx),mx=max(ax,bx);
                for(int j=mn+1; j<=mx; ++j)
                    sp[ay][j][ay+1][j]=sp[ay+1][j][ay][j]=true;
            }
        }
        bool ok=false;
        queue<Grid> q;
        Grid st(sy,sx);
        memset(dir,0,sizeof(dir));
        memset(vis,0,sizeof(vis));
        q.push(st);
        while(!q.empty()&&!ok)
        {
            Grid t=q.front();
            q.pop();
            for(int i=0; i<4; ++i)
            {
                int xx=t.x+m[i][0],yy=t.y+m[i][1];
                if(!Judge(xx,yy)) continue;
                if(!vis[xx][yy]&&!sp[t.x][t.y][xx][yy])
                {
                    last_grid[xx][yy]=t;
                    dir[xx][yy]=i;
                    vis[xx][yy]=true;
                    if(xx==ey&&yy==ex)
                    {
                        ok=true;
                        break;
                    }
                    q.push(Grid(xx,yy));
                }
            }
        }
        Grid ed(ey,ex);
        Print(ed,st);
        printf("\n");
    }
    return 0;
}