leetcode 1091. 二进制矩阵中的最短路径（C++）

在一个 N × N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。

一条从左上角到右下角、长度为 k 的畅通路径，由满足下述条件的单元格 C_1, C_2, ..., C_k 组成：

• 相邻单元格 C_i 和 C_{i+1} 在八个方向之一上连通（此时，C_i 和 C_{i+1} 不同且共享边或角）
• C_1 位于 (0, 0)（即，值为 grid[0][0]）
• C_k 位于 (N-1, N-1)（即，值为 grid[N-1][N-1]）
• 如果 C_i 位于 (r, c)，则 grid[r][c] 为空（即，grid[r][c] == 0）

返回这条从左上角到右下角的最短畅通路径的长度。如果不存在这样的路径，返回 -1 。

 

示例 1：

输入：[[0,1],[1,0]]
输出：2

示例 2：

输入：[[0,0,0],[1,1,0],[1,1,0]]
输出：4

 

提示：

1. 1 <= grid.length == grid[0].length <= 100
2. grid[i][j] 为 0 或 1

C++

class Solution {
public:
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        int m=grid.size();
        if(1==grid[0][0] || 1==grid[m-1][m-1]) {
            return -1;
        }
        int ans=10000;
        vector<vector<int>> res(m,vector<int>(m,10000));
        queue<pair<int,int>> que;
        que.push({0,0});
        res[0][0]=1;
        int dy[8]={-1,-1,-1,0,0,1,1,1};
        int dx[8]={-1,0,1,-1,1,-1,0,1};
        while(!que.empty()) {
        	int n=que.size();
        	for(int i=0;i<n;i++) {
        		auto it=que.front();
        		que.pop();
        		int r=it.first;
        		int c=it.second;
        		for(int k=0;k<8;k++) {
        			int y=r+dy[k];
        			int x=c+dx[k];
        			if(y>=0 && y<m && x>=0 && x<m && 0==grid[y][x]) {
        				if(res[r][c]+1<res[y][x]) {
        					res[y][x]=res[r][c]+1;
        					que.push({y,x});
        				}
        			}
        		}
        	}
        }
        if(res[m-1][m-1]!=10000) {
        	return res[m-1][m-1];
        }
        return -1;
    }
};