[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