走迷宫-BFS

题目：走迷宫

 

给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。

 

最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

 

请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。

 

数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。

输入格式

第一行包含两个整数 n 和 m。

接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数。

输入样例

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出样例

8

代码

#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
#include<deque>
#include<climits>
using namespace std;

class Solution
{
public:
    int func(vector<vector<int>>& vec, int startx, int starty, int endx, int endy)
    {
        int m = vec.size();
        int n = vec[0].size();
        deque<vector<int>> deq;
        deq.push_back({ startx,starty });
        flag[startx][starty] = 1;
        while (deq.size() != 0)
        {
            int l = deq.size();
            for (int i = 0; i < l; i++)
            {
                vector<int> tmp = deq.front();
                deq.pop_front();
                if (tmp[0] == endx && tmp[1] == endy)
                {
                    return len;
                }
                if (tmp[0] - 1 > 0 && vec[tmp[0] - 1][tmp[1]] == 0 && flag[tmp[0] - 1][tmp[1]] == 0)
                {
                    deq.push_back({ tmp[0] - 1,tmp[1] });
                    flag[tmp[0] - 1][tmp[1]] = 1;
                }
                if (tmp[0] + 1 < m && vec[tmp[0] + 1][tmp[1]] == 0 && flag[tmp[0] + 1][tmp[1]] == 0)
                {
                    deq.push_back({ tmp[0] + 1,tmp[1] });
                    flag[tmp[0] + 1][tmp[1]] = 1;
                }
                if (tmp[1] - 1 > 0 && vec[tmp[0]][tmp[1]-1] == 0 && flag[tmp[0]][tmp[1]-1] == 0)
                {
                    deq.push_back({ tmp[0],tmp[1]-1 });
                    flag[tmp[0]][tmp[1]-1] = 1;
                }
                if (tmp[1] + 1 < n && vec[tmp[0]][tmp[1] + 1] == 0 && flag[tmp[0]][tmp[1] + 1] == 0)
                {
                    deq.push_back({ tmp[0],tmp[1] + 1 });
                    flag[tmp[0]][tmp[1] + 1] = 1;
                }
            }
            len++;
        }
    }

    int len = 0;
    vector<vector<int>> flag;
};

int main()
{
    int m;
    int n;
    cin >> m;
    cin >> n;
    vector<vector<int>> vec;
    for (int i = 0; i < m; i++)
    {
        vector<int> tmp;
        for (int j = 0; j < n; j++)
        {
            int aa;
            cin >> aa;
            tmp.push_back(aa);
        }
        vec.push_back(tmp);
    }
    int startx = 0;
    int starty = 0;
    int endx = vec.size() - 1;
    int endy = vec[0].size() - 1;
    Solution sol;
    sol.flag = vector<vector<int>>(m, vector<int>(n, 0));
    cout << sol.func(vec, startx, starty, endx, endy) << endl;;
    return 0;
}