[Acm] foj 2196 : Escape（广搜）

Problem 2196 Escape
Accept: 22 Submit: 143
Time Limit: 1000 mSec Memory Limit : 32768 KB

Problem Description

小明进入地下迷宫寻找宝藏，找到宝藏后却发生地震，迷宫各处产生岩浆，小明急忙向出口处逃跑。若是丢下宝藏，小明就能迅速离开迷宫，但小明并不想轻易放弃本身的辛苦所得。因此他急忙联系当程序员的朋友你（固然是用手机联系），并告诉你他所面临的状况，但愿你能告诉他是否能成功带着宝藏逃脱。
Input

有多组测试数据。

每组测试数据第一行是一个整数T,表明接下去的例子数。（0<=T<=10）

接下来是T组例子。

每组例子第一行是两个整数N和M。表明迷宫的大小有N行M列（0<=N,M<=1000）。

接下来是一个N*M的迷宫描述。

S表明小明的所在地。

E表明出口,出口只有一个。

.表明能够行走的地方。

！表明岩浆的产生地。（这样的地方会有多个,其个数小于等于10000）

#表明迷宫中的墙，其不只能阻挡小明前进也能阻挡岩浆的蔓延。

小明携带者宝藏每秒只能向周围移动一格，小明不能碰触到岩浆（小明不能和岩浆处在同一格）。

岩浆每秒会向四周不是墙的地方蔓延一格。

小明先移动完成后，岩浆才会蔓延到对应的格子里。

小明能移动到出口，则小明顺利逃脱。

Output

每组测试数据输出只有一行“Yes”或者“No”。 “Yes”表明小明能够成功逃脱。不然输出“No”。
Sample Input

3
5 5
....!
S....
#....
!#...
#E...
2 2
S.
!E
2 2
SE
!.
Sample Output

Yes
No
Yes
Source

福州大学第十二届程序设计竞赛

---

题意：

给你一个n*m的迷宫，迷宫中
S 是起点
E 是终点
. 是路
# 是墙
! 是岩浆
岩浆每秒会蔓延一个格（上下左右），遇到墙没法蔓延。
小明不能触碰岩浆。
每一秒小明先走，而后岩浆蔓延。
判断小明可否顺利逃脱。

思路：

用广搜来作，多用一个二维数组记录岩浆的蔓延。
用节点来记录状态，节点中x，y是坐标，s是走到当前坐标的时间。
广搜时不断将状态push到队列中，能够想象队列中的节点的s值是这样的：01112222233333……
s表明走到当前坐标的时间，是时间，并且是平稳变化的，那么咱们在时间跳变的时候，例如0跳到1,1跳到2这样的时候就更新一下记录岩浆蔓延的地图，让它向外蔓延一个格。
这样小明行走的状态就和岩浆蔓延的时间同步了。
如此正常的广搜便可，走到终点E就算成功，走不到就失败。
(若是在走到终点以前，终点就被覆盖了，那么这种状态也不行)

其实岩浆蔓延是能够优化的，以上思路是每秒时间跳变的时候更新一遍岩浆地图，可是能够在一开始作一个预处理，把岩浆蔓延到地图上全部点的到达时间先求出来，具体作法是将全部岩浆源点加入队列，广搜一遍，求出全部岩浆蔓延的时刻。
如此，只要小明到达该位置的时间 > 岩浆蔓延到该位置的时间，就不能走，由于岩浆比他先到达该位置。

用此优化，时间快了一半，空间几乎没有变化。

---

其实还能够继续优化……
把小明和岩浆的节点都放入队列广搜便可…… 这样就不用再开一个地图预处理。
具体作法是先把小明的位置放入队列，再把岩浆发源地放入节点，这样开始广搜。

提供几组测试数据：

3
3 2
.S
!.
.E
3 3
..S
...
!.E
3 3
..S
!..
..E

结果应是：

No
Yes
Yes

代码：

优化前：

cpp#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;

#define MAXN 1010
#define MAXM 1010

bool isw[MAXN][MAXM];
int isy[MAXN][MAXM];   //是不是岩浆
char a[MAXN][MAXM];

int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
int sx,sy,ex,ey;
int n,m;

struct Node{
    int x;
    int y;
    int s;  //步数
};

bool judge(int x,int y)
{
    if(x<1 || x>n || y<1 || y>m)
        return true;
    if(isw[x][y])   //走过，或是岩浆
        return true;
    if(isy[x][y])   //是不是岩浆
        return true;
    if(a[x][y]=='#')
        return true;
    return false;
}

bool judge2(int x,int y) //岩浆的行走判断
{
    if(x<1 || x>n || y<1 || y>m)
        return true;
    if(isy[x][y])   //是不是岩浆
        return true;
    if(a[x][y]=='#')
        return true;
    return false;
}

void UpdateYanjiang(int t)   //更新岩浆
{
    int i,j,k;
    for(i=1;i<=n;i++){
        for(j=1;j<=m;j++){
            if(isy[i][j]==t){  //若是是最外围的岩浆
                for(k=0;k<4;k++){   //4个方向
                    int nx = i+dx[k];
                    int ny = j+dy[k];
                    if(judge2(nx,ny))
                        continue;
                    isy[nx][ny] = isy[i][j]+1;
                }
            }
        }
    }
}

bool bfs()
{
    queue <Node> q;
    int t = 0;  //记录当前时间
    Node cur,next;
    cur.x = sx;
    cur.y = sy;
    cur.s = 0;
    isw[cur.x][cur.y] = true;
    q.push(cur);
    while(!q.empty()){
        cur = q.front();
        q.pop();
        if(cur.x==ex && cur.y==ey)  //安全到达终点
            return true;

        //没有到达终点，判断是否到了下一秒
        //到达下一秒，岩浆蔓延
        if(cur.s>t){
            t++;
            UpdateYanjiang(t);   //岩浆蔓延
        }

        //若是终点被覆盖，则这种状况不行
        if(isy[ex][ey])
            continue;

        //判断是否已经在岩浆里了
        if(isy[cur.x][cur.y])
            continue;

        int i,nx,ny;
        for(i=0;i<4;i++){
            nx = cur.x + dx[i];
            ny = cur.y + dy[i];
            if(judge(nx,ny))
                continue;
            //能够走
            next.x = nx;
            next.y = ny;
            next.s = cur.s + 1;
            isw[next.x][next.y] = true;
            q.push(next);
        }
    }
    return false;
}


int main()
{
    int T,i,j;
    scanf("%d",&T);
    while(T--){
        memset(a,0,sizeof(a));
        memset(isw,0,sizeof(isw));
        memset(isy,0,sizeof(isy));
        scanf("%d%d",&n,&m);
        //输入
        for(i=1;i<=n;i++){
            getchar();
            for(j=1;j<=m;j++){
                scanf("%c",&a[i][j]);
                if(a[i][j]=='!')    //是岩浆
                    isy[i][j] = 1;
                else if(a[i][j]=='S')
                    sx=i,sy=j;
                else if(a[i][j]=='E')
                    ex=i,ey=j;
            }
        }
        if(bfs())
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}

优化后：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;

#define MAXN 1010
#define MAXM 1010

bool isw[MAXN][MAXM];
int isy[MAXN][MAXM];   //是不是岩浆
char a[MAXN][MAXM];

int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
int sx,sy,ex,ey;
int n,m;

struct Node{
    int x;
    int y;
    int s;  //步数
    Node(){}
    Node(int x,int y,int s):x(x),y(y),s(s){}
};

bool judge(int x,int y,int s)
{
    if(x<1 || x>n || y<1 || y>m)
        return true;
    if(isw[x][y])   //走过，或是岩浆
        return true;
    if(a[x][y]!='E' && isy[x][y]<=s)   //是不是岩浆。且不是终点
        return true;
    if(a[x][y]=='#')
        return true;
    return false;
}

bool judge2(int x,int y) //岩浆的行走判断
{
    if(x<1 || x>n || y<1 || y>m)
        return true;
    if(isy[x][y])   //是不是岩浆
        return true;
    if(a[x][y]=='#')
        return true;
    return false;
}

void Init(queue <Node> &q)
{
    Node cur,next;
    while(!q.empty()){
        cur = q.front();
        q.pop();
        int i,nx,ny;
        for(i=0;i<4;i++){
            nx = cur.x + dx[i];
            ny = cur.y + dy[i];
            if(judge2(nx,ny))
                continue;
            //能够走
            next.x = nx;
            next.y = ny;
            next.s = cur.s + 1;
            isy[next.x][next.y] = next.s;
            q.push(next);
        }
    }
}

bool bfs()
{
    queue <Node> q;
    Node cur,next;
    cur.x = sx;
    cur.y = sy;
    cur.s = 1;
    isw[cur.x][cur.y] = true;
    q.push(cur);
    while(!q.empty()){
        cur = q.front();
        q.pop();
        if(cur.x==ex && cur.y==ey)  //安全到达终点
            return true;

        //若是终点被覆盖，则这种状况不行
        if(isy[ex][ey]<=cur.s)
            continue;

        int i,nx,ny,ns;
        for(i=0;i<4;i++){
            nx = cur.x + dx[i];
            ny = cur.y + dy[i];
            ns = cur.s + 1;
            if(judge(nx,ny,ns))
                continue;
            //能够走
            next.x = nx;
            next.y = ny;
            next.s = ns;
            isw[next.x][next.y] = true;
            q.push(next);
        }
    }
    return false;
}


int main()
{
    int T,i,j;
    scanf("%d",&T);
    while(T--){
        memset(a,0,sizeof(a));
        memset(isw,0,sizeof(isw));
        memset(isy,0,sizeof(isy));
        queue <Node> q;
        scanf("%d%d",&n,&m);
        //输入
        for(i=1;i<=n;i++){
            getchar();
            for(j=1;j<=m;j++){
                scanf("%c",&a[i][j]);
                if(a[i][j]=='!'){    //是岩浆
                    isy[i][j] = 1;
                    q.push(Node(i,j,1));    //岩浆发源地入队列
                }
                else if(a[i][j]=='S')
                    sx=i,sy=j;
                else if(a[i][j]=='E')
                    ex=i,ey=j;
            }
        }
        Init(q); //初始化岩浆地图
        if(bfs())
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}

再次优化

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;

#define MAXN 1010
#define MAXM 1010

bool isw[MAXN][MAXM];
char a[MAXN][MAXM];

int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
int sx,sy,ex,ey;
int n,m;

struct Node{
    int x;
    int y;
    int s;  //步数，-1说明是岩浆
    Node(){}
    Node(int x,int y,int s):x(x),y(y),s(s){}
};

bool judge(int x,int y)
{
    if(x<1 || x>n || y<1 || y>m)
        return true;
    if(isw[x][y])   //走过，或是岩浆
        return true;
    if(a[x][y]=='!')    //遇到岩浆
        return true;
    if(a[x][y]=='#')    //遇到墙
        return true;
    return false;
}

bool judge2(int x,int y) //岩浆的行走判断
{
    if(x<1 || x>n || y<1 || y>m)
        return true;
    if(a[x][y]=='!')   //走过
        return true;
    if(a[x][y]=='#')
        return true;
    return false;
}

bool bfs()
{
    int cnt = 1;
    queue <Node> q;
    Node cur,next;
    cur.x = sx;
    cur.y = sy;
    cur.s = 0;
    isw[cur.x][cur.y] = true;
    q.push(cur);
    int i,j;
    //将岩浆发源地放入队列
    for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
            if(a[i][j]=='!'){
                q.push(Node(i,j,-1));    //-1表示岩浆节点
            }
    while(!q.empty()){
        cur = q.front();
        q.pop();
        if(cur.s>=0){    //该位置是小明
            cnt--;
            if(cur.x==ex && cur.y==ey)  //安全到达终点
                return true;

            if(a[cur.x][cur.y]=='!')    //已身处岩浆
                continue;

            int i,nx,ny,ns;
            for(i=0;i<4;i++){
                nx = cur.x + dx[i];
                ny = cur.y + dy[i];
                ns = cur.s + 1;
                if(judge(nx,ny))
                    continue;
                //能够走
                next.x = nx;
                next.y = ny;
                next.s = ns;
                isw[next.x][next.y] = true;
                cnt++;
                q.push(next);
            }
            if(cnt==0)
                return false;
        }
        else{   //该位置是岩浆
            if(cur.x==ex && cur.y==ey)  //岩浆先到达终点
                return false;

            int i,nx,ny,ns;
            for(i=0;i<4;i++){
                nx = cur.x + dx[i];
                ny = cur.y + dy[i];
                if(judge2(nx,ny))
                    continue;
                //能够走
                next.x = nx;
                next.y = ny;
                next.s = -1;
                a[next.x][next.y] = '!';    //岩浆蔓延
                q.push(next);
            }
        }
    }
    return false;
}


int main()
{
    int T,i,j;
    scanf("%d",&T);
    while(T--){
        memset(a,0,sizeof(a));
        memset(isw,0,sizeof(isw));
        scanf("%d%d",&n,&m);
        //输入
        for(i=1;i<=n;i++){
            getchar();
            for(j=1;j<=m;j++){
                scanf("%c",&a[i][j]);
                if(a[i][j]=='S')
                    sx=i,sy=j;
                else if(a[i][j]=='E')
                    ex=i,ey=j;
            }
        }
        if(bfs())
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}

时间从 437 ms > 281 ms > 156 ms