bfs-最短路问题

bfs:宽度优先搜索，一层层的搜索，每次移动的距离是一，所以可以用来解决边长为一的最短路问题。

例题：

迷宫用一个 R×C 的字符矩阵来表示。

字符 S 表示阿尔吉侬所在的位置，字符 E 表示奶酪所在的位置，字符 # 表示墙壁，字符 . 表示可以通行。

阿尔吉侬在 1 个单位时间内可以从当前的位置走到它上下左右四个方向上的任意一个位置，但不能走出地图边界。

对于每一组数据，输出阿尔吉侬吃到奶酪的最少单位时间。

若阿尔吉侬无法吃到奶酪，则输出“oop!”（只输出引号里面的内容，不输出引号）。

 

思路：

首先发现这就是一道最短路问题，用bfs可以很快解决。

bfs:  1.char  g[N][N] ,用一个字符串数组来存储地图

        2.直接使用c++中的队列

        3.还需要一个距离数组来存储俩个点直接的距离。

注意点：由于有多组数据，所以每次都要情况dist数组，队列的定义要放在bfs函数中，这样每次都创建一个新队列。

 

代码：

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>

using namespace std;
const int N=210;
typedef pair<int,int> PII;
#define x first
#define y second
char g[N][N];
int dist[N][N];


int r,c;

int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};

int bfs(PII start,PII end)
{
    queue<PII> q;
    memset(dist,-1,sizeof dist);
    q.push(start);
    dist[start.x][start.y]=0;
    
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            int a=t.x+dx[i],b=t.y+dy[i];
            if(a<0 || a>=r || b<0 || b>=c) continue;
            if(dist[a][b]!=-1) continue;
            if(g[a][b]=='#') continue;
            
            dist[a][b]=dist[t.x][t.y]+1;
            if(end==make_pair(a,b)) return dist[a][b];
            q.push({a,b});
            
        }
    }
    
    return -1;
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        
        cin>>r>>c;
        for(int i=0;i<r;i++)
            cin>>g[i];
            
        PII start,end;
        for(int i=0;i<r;i++)
            for(int j=0;j<c;j++)
                if(g[i][j]=='S')
                    start={i,j};
                else if(g[i][j]=='E')
                    end={i,j};
                    
        int res=bfs(start,end);
        
        if(res==-1) cout<<"oop!"<<endl;
        else cout<<res<<endl;
    }
    
    return 0;
}