搜索实现迷宫（队列）

bfs

#include <iostream>
#include <queue>

using namespace std;

#define MAX_N 10
#define MAX_M 10

const int INF = 100000000;

typedef pair<int ,int> P;

char maze[MAX_N][MAX_M+1] =
{
    { '#', 'S', '#' , '#','#', '#', '#', '#', '.', '#'},
    { '.', '.', '.' , '.','.', '.', '#', '.', '.', '#'},
    { '.', '#', '.' , '#','#', '.', '#', '#', '.', '#'},
    { '.', '#', '.' , '.','.', '.', '.', '.', '.', '.'},
    { '#', '#', '.' , '#','#', '.', '#', '#', '#', '#'},
    { '.', '.', '.' , '.','#', '.', '.', '.', '.', '#'},
    { '.', '#', '#' , '#','#', '#', '#', '#', '.', '#'},
    { '.', '.', '.' , '.','#', '.', '.', '.', '.', '.'},
    { '.', '#', '#' , '#','#', '.', '#', '#', '#', '.'},
    { '.', '.', '.' , '.','#', '.', '.', '.', 'G', '#'},
};

int N = 10, M = 10;
int sx = 0;
int sy = 1;
int gx = 9;
int gy = 8;
int d[MAX_N][MAX_M];
int dx[4] = {1, 0, -1, 0}, dy[] = { 0, 1, 0, -1};

int bfs()
{
    queue<P> que;
    // 初始化所有距离为INF
    for( int i = 0; i < N;i++)
    {
        for( int j = 0; j <M; j++)
        {
            d[i][j] = INF;
        }
    }

    // 将起点加入队列，并将这一点的距离设置为0
    que.push(P(sx, sy));
    d[sx][sy] = 0;
    while( que.size())
    {
        P p = que.front();que.pop();
        if(p.first == gx&& p.second == gy)
            break;

        // 向四个方向循环
        for( int i = 0; i <4; i++ )
        {
            // 移动之后的坐标
            int nx = p.first +dx[i];
            int ny = p.second+ dy[i];

            // 判断是否可以移动以及是否已经访问过(d[nx][ny] != INF即已经访问过)
            if(0<= nx&& nx < N && 0 <= ny && ny < M &&maze[nx][ny] != '#' && d[nx][ny] == INF)
            {
                // 可以移动的话，将它加入队列，并且到达该位置的距离确定为到p的距离+1
                que.push(P(nx,ny));
                d[nx][ny] = d[p.first][p.second]+ 1;
            }
        }
    }

    return d[gx][gy];
}

int main()
{

    int res = bfs();
    cout <<"Result: " << res << endl;
    return 0;
}

#include<iostream>
#include<queue>
using namespace std;


const int INF= 1e+8;
const int  max_n=10;
typedef pair<int,int> P;  //用pair表示状态 和map一样 较方便


//输入
char maze[max_n][max_n+1];// 表示迷宫的字符串数组
int n=10,m=10;
int sx=0,sy=1;//起点坐标
int gx=9,gy=8;//终点坐标

int d[max_n][max_n];  //到各个位置的最短距离的数组

//四个方向的向量
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
//求从（sx，sy）到（gx，gy）的距离
//如果无法到达，则是INF


bool limit(int x,int y)
{
	return 0<= x&& x < n && 0 <= y && y < m &&maze[x][y] != '#' && d[x][y] == INF;
}
int bfs()
{
	queue<P> que;
	for(int i=0;i<n;i++)  //初始化为INF
		for(int j=0;j<m;j++)
			d[i][j]=INF;
	que.push(P(sx,sy));//将起点加入队列，并把这一点的距离设为0
	d[sx][sy]=0;
	
	//不断循环知道队列的长度为0
	while(que.size())  //队列的长度
	{
		//从队列的最前端取出元素
		P p=que.front();que.pop();//并删除该元素
		//如果取出的状态是终点则 结束搜索
		if(p.first==gx&&p.second==gy)
			break;

		//四个方向的循环
		for(int i=0;i<4;i++)
		{
			//移动后的位置标记为（nx，ny）
			int nx=p.frist+dx[i];
			int ny=p.second+dy[i];
			//判断是否可以移动以及是否已经访问过
			if(limit(nx,ny))
			{
				que.push(p(nx,ny));
				d[nx][ny]=d[p.first][p.second]+1;
			}
		}
	}
	return d[gx][gy];
}

void solve()
{
	int res=bfs();
	cout<<res<<endl;
}

int main()
{
	solve();
	return 0;
}