leetcode 5286 网格中的最短路径

给你一个 m * n 的网格，其中每个单元格不是 0（空）就是 1（障碍物）。每一步，您都可以在空白单元格中上、下、左、右移动。

如果您 最多 可以消除 k 个障碍物，请找出从左上角 (0, 0) 到右下角 (m-1, n-1) 的最短路径，并返回通过该路径所需的步数。如果找不到这样的路径，则返回 -1。

解题思路是BFS，每遇到一个障碍物，就看当前还有没有机会越过障碍物。第一次写的时候没有考虑到每个格子的状态其实不仅仅是一个的，因为达到当前格子走过的障碍物数目是不同的，所以vis要增加一维保存

走到当前格子，总共经过多少个障碍物了。其次格子的状态数目是有限制的，最多是n*m，注意这一条件，不然死循环了。

最后代码如下：

class Solution {
public:
    struct T{
        int x,y;
        int step;
        int k;
    };
    queue<T>q;
    int dx[4]={-1,1,0,0};
    int dy[4]={0,0,1,-1};
    bool vis[41][41][41*41];
    int bfs(vector<vector<int>>& grid,int m,int n,int k)
    {
        memset(vis,0,sizeof(vis));
        T init;
        init.x=0;init.y=0;
        init.step=0;init.k=0;
        vis[0][0][0]=1;
        q.push(init);
        while(!q.empty())
        {
            T tmp=q.front();
            if(tmp.x==m-1&&tmp.y==n-1)
                return tmp.step;
            q.pop();
            for(int i=0;i<4;i++)
            {
                int xx=tmp.x+dx[i];
                int yy=tmp.y+dy[i];
                if(xx>=0&&xx<m&&yy>=0&&yy<n)
                {
                    if(grid[xx][yy]==1&&tmp.k+1<=k&&!vis[xx][yy][tmp.k+1]&&tmp.k+1<=n*m)
                    {
                        //cout<<"ww: "<<xx<<" "<<yy<<" "<<tmp.k+1<<endl;
                        vis[xx][yy][tmp.k+1]=1;
                        T tp;
                        tp.k=tmp.k+1;
                        tp.step=tmp.step+1;
                        tp.x=xx;
                        tp.y=yy;
                        q.push(tp);
                    }
                    else if(grid[xx][yy]==0&&tmp.k<=n*m&&!vis[xx][yy][tmp.k])
                    {
                        vis[xx][yy][tmp.k]=1;
                        T tp;
                        tp.k=tmp.k;
                        tp.step=tmp.step+1;
                        tp.x=xx;
                        tp.y=yy;
                        q.push(tp);
                    }
                }
            }
        }
        return -1;
    }
    int shortestPath(vector<vector<int>>& grid, int k) {
        int m=grid.size();
        int n=grid[0].size();
        return bfs(grid,m,n,k);
    }
};