Leetcode1210-穿过迷宫的最少移动次数

wobushihaorenF

已于 2022-12-13 12:15:18 修改

阅读量110

点赞数

分类专栏： Leetcode BFS 文章标签： leetcode 哈希算法算法

于 2022-12-13 11:53:47 首次发布

本文链接：https://blog.csdn.net/aaa7888210/article/details/128299772

版权

Leetcode 同时被 2 个专栏收录

130 篇文章 1 订阅

订阅专栏

BFS

24 篇文章 0 订阅

订阅专栏

BFS

分两种的情况：

①蛇是横着的，则有三种状态的变换：向右走，向下走，顺时针旋转

②蛇是竖着的，亦有三种状态的变换：向下走，向右走，逆时针旋转

同时用哈希表来记录蛇走过的状态来去重，细节多实现略繁琐但思路不难。

class Solution {
public:
    int minimumMoves(vector<vector<int>>& grid) {
        int m=grid.size();
        vector<unordered_set<int>> g(m*m);
        queue<pair<int,int>> q;
        g[0].insert(1);
        q.push({0,1});
        int len=0;
        while(!q.empty()){
            int sz=q.size();
            while(sz--){
                auto [t,h]=q.front();
                q.pop();
                int tx=t/m,ty=t%m;
                int hx=h/m,hy=h%m;
                if(tx==m-1&&ty==m-2&&hx==m-1&&hy==m-1) return len;
                if(tx==hx){
                    if(hy+1<m&&!grid[hx][hy+1]){
                        if(!g[hx*m+hy].count(hx*m+hy+1)){
                            q.push({hx*m+hy,hx*m+hy+1});
                            g[hx*m+hy].insert(hx*m+hy+1);
                        }
                    }
                    if(hx+1<m&&!grid[hx+1][hy]&&!grid[tx+1][ty]){
                        if(!g[(tx+1)*m+ty].count((hx+1)*m+hy)){
                            q.push({(tx+1)*m+ty,(hx+1)*m+hy});
                            g[(tx+1)*m+ty].insert((hx+1)*m+hy);
                        }
                        if(!g[tx*m+ty].count((tx+1)*m+ty)){
                            q.push({tx*m+ty,(tx+1)*m+ty});
                            g[tx*m+ty].insert({tx*m+ty,(tx+1)*m+ty});
                        }
                    }
                }else if(ty==hy){
                    if(hx+1<m&&!grid[hx+1][hy]){
                        if(!g[hx*m+hy].count((hx+1)*m+hy)){
                            q.push({hx*m+hy,(hx+1)*m+hy});
                            g[hx*m+hy].insert({hx*m+hy,(hx+1)*m+hy});
                        }
                    }
                    if(hy+1<m&&!grid[hx][hy+1]&&!grid[tx][ty+1]){
                        if(!g[tx*m+ty+1].count(hx*m+hy+1)){
                            q.push({tx*m+ty+1,hx*m+hy+1});
                            g[tx*m+ty+1].insert({tx*m+ty+1,hx*m+hy+1});
                        }
                        if(!g[tx*m+ty].count(tx*m+ty+1)){
                            q.push({tx*m+ty,tx*m+ty+1});
                            g[tx*m+ty].insert({tx*m+ty,tx*m+ty+1});
                        }
                    }
                }
            }
            len++;
        }
        return -1;
    }
};

时间复杂度：O（n^n）。

空间复杂度：O（n^n）。