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

给你一个 m x n 的网格图 grid 。 grid 中每个格子都有一个数字，对应着从该格子出发下一步走的方向。 grid[i][j] 中的数字可能为以下几种情况：

1 ，下一步往右走，也就是你会从 grid[i][j] 走到 grid[i][j + 1]
2 ，下一步往左走，也就是你会从 grid[i][j] 走到 grid[i][j - 1]
3 ，下一步往下走，也就是你会从 grid[i][j] 走到 grid[i + 1][j]
4 ，下一步往上走，也就是你会从 grid[i][j] 走到 grid[i - 1][j]
注意网格图中可能会有 无效数字 ，因为它们可能指向 grid 以外的区域。

一开始，你会从最左上角的格子 (0,0) 出发。我们定义一条 有效路径 为从格子 (0,0) 出发，每一步都顺着数字对应方向走，最终在最右下角的格子 (m - 1, n - 1) 结束的路径。有效路径 不需要是最短路径 。

你可以花费 cost = 1 的代价修改一个格子中的数字，但每个格子中的数字 只能修改一次 。

请你返回让网格图至少有一条有效路径的最小代价
链接：🔗
 

权值为0,1的最短路可以用双端队列 +　BFS来完成

思路上来源于堆优化版的Dijkstra

class Solution {
public:
    int minCost(vector<vector<int>>& grid) {
        
        int dx[] = {0,0,1,-1};
        int dy[] = {1,-1,0,0};
        
        int n = grid.size(), m = grid[0].size();
        
        int vis[n][m],dist[n][m];
        
        memset(dist,0x3f,sizeof dist);
        memset(vis,0,sizeof vis);
        
        typedef pair<int,int> PII;
        
        deque<PII> q;
        
        q.push_front({0,0});  
        dist[0][0] = 0;
        
        while(!q.empty()){
            auto t = q.front();
            q.pop_front();
            int x = t.first;
            int y = t.second;
            if (vis[x][y]) continue;
            vis[x][y] = 1;
            
            for (int i = 0; i < 4; ++i){
                int nx = x + dx[i],ny = y  + dy[i];
                if (nx < 0 || nx >= n || ny < 0 || ny >= m)
                    continue;
                int w = 0;
                if (grid[x][y] - 1 != i) w = 1;　　  // grid中存储的是可直接走过去的方向,grid[x][y]取值从1到4,下标i对应的dx和dy也是代表方向,只不过i从0到3,因此需要先减一
                if (dist[nx][ny] > dist[x][y] + w){
                    dist[nx][ny] = dist[x][y] + w;
                }
                if (w) q.push_back({nx,ny});
                else q.push_front({nx,ny});
            }
        }
        return dist[n - 1][m - 1];
    }
};