HDU 5040 Instrusive BFS 性质优化

题意：给出一个迷宫，求从起点M到终点T的最短时间。

          行走规则如下：1.正常的格子向四个方向走，花费时间1。2.迷宫内有监视器，给出监视器初始时的方向。监视器会每秒顺时针转90度。监视的范围为监视器所在格子和对应方向的一个格子。人在没有伪装的情况下，走到被监视的范围会被发现。3.人有一个技能：伪装。伪装后，可以不被监视器发现。但如果要移动的话，移动一个格子的时间为3.当且在以下情况下需要伪装前进：当前格子被监视，前往的格子在当前时间下被监视。

思路：看到走迷宫就是bfs了。现在我们要考虑如何对监视器处理。

           比赛时，我们首先的想法是利用spfa的思想，不断更新最短距离。如果该点被更新最短距离，那就可能会对其他的点有影响，继续入队。最后这样就TLE了。

          后来，我们想到，其实我们这样需要更新的状态太多。需要利用性质优化。

          对于没有被监视的点，我们需要的时间是1，没法优化。

          但是对于被监视的点，需要的时间是3，但是经过这个点最少需要3个时间吗？显然不是，这个要根据当前格、目标格和这两个格的下一秒，这四个状态是否被监视来决定。

          1.当前格子当前时间被监视，但下一秒，当前格子和目标格子都没有被监视。这个时候最优的方案就是等一下。需要的时间为2.

          2.当前格子当前时间被监视，下一秒，当前格子和目标格子中至少有一个格子被监视，那我们的等待是没有意义的，直接前进。需要的时间为3.

          3.当前格子当前时间没有被监视，目标格子当前时间被监视，但下一秒，当前格子和目标格子都没有被监视。最优的方案是等一秒，需要的时间为2.

          4.当前格子当前时间没有被监视，目标格子当前时间和下一时间都被监视，同上，我们的等待也是没有意义的，直接前进，需要的时间为3.

          这样，就可以大大减少BFS的状态数。

代码如下：

#include <cstring>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstdlib>
using namespace std;

const int INF=0x3f3f3f3f;

int dir1[]={0,0,-1,1};
int dir2[]={1,-1,0,0};
char a[600][600];
int n;
int sx,sy,ex,ey;
struct point
{
    int x,y;
}   que[100001000];
bool inque[600][600];
int dis[600][600];

int ca_(int x,int y)
{
    if (a[x][y]!='.' && a[x][y]!='#' && x>=1 && x<=n && y>=1 && y<=n)
        return 1;
    return 0;
}

int check(int x,int y,int ti_x,int ti_y,int addti)
{
    int ca;
    if (ca_(x,y)) return 0;
    if (ca_(x-1,y))
    {
        ca=(a[x-1][y]-'0'+dis[ti_x][ti_y]+addti)%4;
        if (ca==2) return 0;
    }
    if (ca_(x,y+1))
    {
        ca=(a[x][y+1]-'0'+dis[ti_x][ti_y]+addti)%4;
        if (ca==3) return 0;
    }
    if (ca_(x+1,y))
    {
        ca=(a[x+1][y]-'0'+dis[ti_x][ti_y]+addti)%4;
        if (ca==0) return 0;
    }
    if (ca_(x,y-1))
    {
        ca=(a[x][y-1]-'0'+dis[ti_x][ti_y]+addti)%4;
        if (ca==1) return 0;
    }
    return 1;
}

int bfs(int x,int y)
{
    int f,t;
    que[1].x=x;que[1].y=y;
    inque[x][y]=true;
    f=1;
    t=0;
    while (t<f)
    {
        t++;
        int px,py,tx,ty;
        px=que[t].x;py=que[t].y;
        inque[px][py]=false;
        for (int i=0;i<4;i++)
        {
            tx=px+dir1[i];
            ty=py+dir2[i];
            if (check(px,py,px,py,0)==0)
            {
                if (tx>=1 && tx<=n && ty>=1 && ty<=n && a[tx][ty]!='#')
                {
                    if (check(px,py,px,py,1)!=0 && check(tx,ty,px,py,1)!=0)
                    {
                        if (dis[tx][ty]>dis[px][py]+2)
                        {
                            dis[tx][ty]=dis[px][py]+2;
                            if (!inque[tx][ty])
                            {
                                f++;
                                que[f].x=tx;
                                que[f].y=ty;
                                inque[tx][ty]=true;
                            }
                        }
                    }
                    else
                    {
                        if (dis[tx][ty]>dis[px][py]+3)
                        {
                            dis[tx][ty]=dis[px][py]+3;
                            if (!inque[tx][ty])
                            {
                                f++;
                                que[f].x=tx;
                                que[f].y=ty;
                                inque[tx][ty]=true;
                            }
                        }
                    }
                }
            }
            else
            if (tx>=1 && tx<=n && ty>=1 && ty<=n && a[tx][ty]!='#')
            {
                if (check(tx,ty,px,py,0)==0)
                {
                    if (check(px,py,px,py,1)!=0 && check(tx,ty,px,py,1)!=0)
                    {
                        if (dis[tx][ty]>dis[px][py]+2)
                        {
                            dis[tx][ty]=dis[px][py]+2;
                            if (!inque[tx][ty])
                            {
                                f++;
                                que[f].x=tx;
                                que[f].y=ty;
                                inque[tx][ty]=true;
                            }
                        }
                    }
                    else
                    {
                        if (dis[tx][ty]>dis[px][py]+3)
                        {
                            dis[tx][ty]=dis[px][py]+3;
                            if (!inque[tx][ty])
                            {
                                f++;
                                que[f].x=tx;
                                que[f].y=ty;
                                inque[tx][ty]=true;
                            }
                        }
                    }
                }
                else
                {
                    if (dis[tx][ty]>dis[px][py]+1)
                    {
                        dis[tx][ty]=dis[px][py]+1;
                        if (!inque[tx][ty])
                        {
                            f++;
                            que[f].x=tx;
                            que[f].y=ty;
                            inque[tx][ty]=true;
                        }
                    }
                }
            }
        }
    }
    if (dis[ex][ey]==INF) return -1;
    return dis[ex][ey];
}

int main()
{
    int T;
    int i,j;
    int ca=0;
    //freopen("main.in","r",stdin);
    scanf("%d",&T);
    while (T--)
    {
        scanf("%d",&n);
        for (i=1;i<=n;i++)
        {
            scanf("%s",a[i]+1);
            for (j=1;j<=n;j++)
            {
                if (a[i][j]=='M')
                {
                    a[i][j]='.';
                    sx=i;sy=j;
                }
                if (a[i][j]=='T')
                {
                    a[i][j]='.';
                    ex=i;ey=j;
                }
                if (a[i][j]=='N') a[i][j]='0';
                if (a[i][j]=='E') a[i][j]='1';
                if (a[i][j]=='S') a[i][j]='2';
                if (a[i][j]=='W') a[i][j]='3';
            }
        }
        memset(dis,0x3f,sizeof(dis));
        memset(inque,false,sizeof(inque));
        dis[sx][sy]=0;
        printf("Case #%d: %d\n",++ca,bfs(sx,sy));
    }
    return 0;
}