0-1BFS算法求最短距离

- 本人的LeetCode账号：Router，欢迎关注获取每日一题题解，快来一起刷题呀~

• 本人Github账号：Grotherdieck，欢迎$follow$获取博客内容源码。
  

一、原理

  我们都知道通过BFS，可以在时间复杂度O(N)(N是点数)下找到任意边权值都为1的图中两点的最短距离，这是基于一个事实：后入队列的点的离起点的距离一定比先入队列的点离起点的距离远(这里是单调不减)，这样才能去更新后一个点离起点的距离是前一个点离起点的距离。

  因此如果把距离改成可能是0或者1的时候，BFS就可能不会再求出最短距离了，比如当前有一个离当前点距离是1的点待入队列，后续还有一个距离为0的点待入队列，这是完全可能的，但是因为距离是1的会先入队列，距离是0的点会后入队列，从而就破坏了BFS的正确性基于的事实：后入队列的点的离起点的距离一定比先入队列的点离起点的距离远(这里是单调不减)。

  但是我们可以这样：把队列换成双端队列deque，新的点入队列时，让距离为0的点插入队头，让距离为1的点插入队尾。

  这样保证了队列的点中从头往尾数，离起点的距离单调不减，因此又可以用BFS了，这种BFS被称为0-1BFS。

二、模板题

  移动到一个空单元格可以认为是两点的边的距离是0，移动到一个障碍物并拆除障碍物可以认为两点的距离是1，因此这就是一道典型的0-1BFS的题目，写成模板即可AC。

class Solution {
public:
    typedef pair<int, int> pii;
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int minimumObstacles(vector<vector<int>>& grid) 
    {
        deque<pii> dq;
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> dist(m, vector<int>(n, -1));
        dq.push_front({0, 0});
        dist[0][0] = 0;
        while (!dq.empty())
        {
            auto p = dq.front(); dq.pop_front();
            int x = p.first, y = p.second;
            for (int i = 0; i < 4; ++i)
            {
                int nx = x + dx[i], ny = y + dy[i];
                if (nx < 0 || nx >= m || ny < 0 || ny >= n || dist[nx][ny] >= 0) continue;
                int g = grid[nx][ny];
                dist[nx][ny] = dist[x][y] + g;
                if (g == 0) dq.push_front({nx, ny});
                else dq.push_back({nx, ny});
            }
        }
        return dist[m - 1][n - 1];
    }
};

三、使网格图至少有一条有效路径的最小代价

1368. 使网格图至少有一条有效路径的最小代价

  这题也是同理，如果当前点是正好由上一个点直接通过格子代表的方向过来的话，那么两点距离为0，否则两点距离为1，我们要求的就是起点(0, 0)到终点(m - 1, n - 1)的最短距离，套用模板即可。

class Solution {
public:
    typedef pair<int, int> pii;
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int minCost(vector<vector<int>>& grid) 
    {
        int m = grid.size(), n = grid[0].size();
        deque<pii> dq;
        vector<vector<int>> dist(m, vector<int>(n, 0x3f3f3f3f));
        dq.push_front({0, 0});
        dist[0][0] = 0;
        while (!dq.empty())
        {
            auto p = dq.front(); dq.pop_front();
            for (int i = 0; i < 4; ++i)
            {
                int nx = p.first + dx[i], ny = p.second + dy[i];
                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
                int g = (i + 1 == grid[p.first][p.second] ? 0 : 1);
                if (g + dist[p.first][p.second] < dist[nx][ny])
                {
                    dist[nx][ny] = g + dist[p.first][p.second];
                    if (g == 0) dq.push_front({nx, ny});
                    else dq.push_back({nx, ny});
                }
            }
        }
        return dist[m - 1][n - 1];
    }
};