我：DFS你下辈子学一学BFS吧，总超时不好！

leetcode1091 二进制矩阵中的最短路径

这道题可以说会BFS的是毫无难度的，但本人一个DFS好手折陨于此，实属不甘！

说实话，这已经不是我第一次用DFS去写类似题型了，就是因为懒，不想学BFS，想一招鲜吃遍天！以至于，我错过了几次面试机会！！如今又被DFS给整了，超时超时超时！！！

每次写到超时，我都怀疑我是不是代码错了，但是算了案例没毛病。

不能再这样了，BFS必须掌握起来！！！

先上一手DFS写法，小用例是能过的，答案目前来看是准确的：

#include<iostream>
#include<vector>
#include<string>

using namespace std;
int dx[8] = { -1,-1,-1,0,0,1,1,1 };
int dy[8] = { -1,0,1,-1,1,-1,0,1 };
int endx;
int endy;
int minpath = INT_MAX;
int actpath = 1;
bool flag = false;
void dfs(vector<vector<int>>& grid, int x, int y, vector<vector<int>>& used)
{
    if (x == endx && y == endy)
    {
        minpath = minpath < actpath ? minpath : actpath;
        flag = true;
        return;
    }
    for (int i = 0; i < 8; i++)
    {
        int sx = x + dx[i];
        int sy = y + dy[i];
        if (sx<0 || sy<0 || sx>grid.size() - 1 || sy>grid[0].size() - 1 || grid[sx][sy] == 1 || used[sx][sy] == 1)
            continue;
        used[sx][sy] = 1;
        actpath++;
        dfs(grid, sx, sy, used);
        actpath--;
        used[sx][sy] = 0;
    }
    return;
}
int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
    if (grid[0][0] != 0)return -1;
    endx = grid[0].size() - 1;
    endy = grid.size() - 1;
    vector<vector<int>>used(grid.size(), vector<int>(grid[0].size(), 0));
    used[0][0] = 1;
    dfs(grid, 0, 0, used);
    if (flag)
        return minpath;
    else
        return -1;
}
int main()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int>>grid(n,vector<int>(m,0));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> grid[i][j];
        }
    }
    int numpath;
    numpath=shortestPathBinaryMatrix(grid);
    cout << numpath;
	return 0;
}

 

 

 但是leetcode  7*7 的案例过不了！，估计就是由于它有8种走法，给自己干懵逼了！

学习BFS写法，迫在眉睫！！！！：

某佬的BFS模板：

void BFS()
{
    定义队列;
    定义备忘录，用于记录已经访问的位置；

    判断边界条件，是否能直接返回结果的。

    将起始位置加入到队列中，同时更新备忘录。

    while (队列不为空) {
        获取当前队列中的元素个数。
        for (元素个数) {
            取出一个位置节点。
            判断是否到达终点位置。
            获取它对应的下一个所有的节点。
            条件判断，过滤掉不符合条件的位置。
            新位置重新加入队列。
        }
    }

}

现在，改由我这个DFS选手上场，照猫画虎！

将将！

BFS代码：

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
struct coordinate//结构体用来定义坐标
{
    int x;
    int y;
};
int dx[8] = { -1,-1,-1,0,0,1,1,1 };
int dy[8] = { -1,0,1,-1,1,-1,0,1 };
int endx;
int endy;
//int minpath = INT_MAX;
int actpath = 1;
bool flag = false;
queue<coordinate>q;//声明一个队列：存放的数据类型为坐标（结构体表示）
int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
    //判断显然不能到达的情况
    if (grid[0][0] != 0)return -1;
    endx = grid[0].size() - 1;
    endy = grid.size() - 1;
    if (grid[endx][endy] != 0)return -1;
    
    //定义一个路径记录图，用来记录该位置是否走过，初始为 0
    vector<vector<int>>used(grid.size(), vector<int>(grid[0].size(), 0));
    
    //将起点坐标加入队列中，表示从此位置开始
    //起点位置坐标已经走过，标记为 1
    q.push({ 0,0 });
    used[0][0] = 1;
   
    //开始广度优先遍历
    while (!q.empty())//当队列目前不为空，说明这些路径都可以走
    {
        int size = q.size();//记录当前队列的大小
        for (int i = 0; i < size; i++)
        {
            //记录队列首部元素坐标
            coordinate  nowcoordinate = q.front();
            q.pop();

            //如果队首坐标满足条件，不需要继续执行了，直接返回
            if (nowcoordinate.x == endx && nowcoordinate.y == endy)
            {
                flag = true;
                return actpath;
            }
            //否则 继续将该节点的周边所有可能的点都加入队列中
             for (int j = 0; j < 8; j++)
             {
                  int sx = nowcoordinate.x + dx[j];
                  int sy = nowcoordinate.y + dy[j];
                 
                 //边界条件
                 if (sx<0 || sy<0 || sx>grid.size() - 1 || sy>grid[0].size() - 1 || grid[sx][sy] == 1 || used[sx][sy] == 1)
                     continue;

                 //将可以到达的坐标点加入队列，并设置此位置的标记
                 q.push({ sx,sy });
                 used[sx][sy] = 1;
             }   
        }
        actpath++;//记录遍历的深度  
    }
    if (flag)return actpath;
    return -1;
}
int main()
{
    int n, m;
    cin >> n >> m;
    vector<vector<int>>grid(n, vector<int>(m, 0));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> grid[i][j];
        }
    }
    int numpath;
    numpath = shortestPathBinaryMatrix(grid);
    cout << numpath;
    return 0;
}