LeetCode 1391. 检查网格中是否存在有效路径 (DFS+并查集)

文章目录

  • 题目(图的静态连通性)
  • 题解
    • 最朴实的DFS做法
    • 比较精简的写法
    • 建图+FloodFill
    • 并查集维护图的连通性

题目(图的静态连通性)

给你一个 m x n 的网格 grid。网格里的每个单元都代表一条街道。grid[i][j] 的街道可以是:

1 表示连接左单元格和右单元格的街道。
2 表示连接上单元格和下单元格的街道。
3 表示连接左单元格和下单元格的街道。
4 表示连接右单元格和下单元格的街道。
5 表示连接左单元格和上单元格的街道。
6 表示连接右单元格和上单元格的街道。
LeetCode 1391. 检查网格中是否存在有效路径 (DFS+并查集)_第1张图片
你最开始从左上角的单元格 (0,0) 开始出发,网格中的「有效路径」是指从左上方的单元格 (0,0) 开始、一直到右下方的 (m-1,n-1) 结束的路径。该路径必须只沿着街道走。

注意:你 不能 变更街道。

如果网格中存在有效的路径,则返回 true,否则返回 false 。

题解

最朴实的DFS做法

对于每一种不同的街道,它的转向是确定的,转完之后能够匹配的街道也是确定的,挨个枚举就好了。
注意防止左右往返的情况,所以一定要用一个visited[][]数组来记录一下,防止搜索冗余。

bool visited[310][310];
class Solution {
     
public:
    int m,n;
    vector<vector<int>> grid;
    
    bool hasValidPath(vector<vector<int>>& grid) {
     
        this->grid = grid;
        memset(visited, 0, sizeof(visited));
        m = (int)grid.size();
        n = (int)grid[0].size();
        visited[0][0] = true;
        return dfs(0, 0);
    }
    
    bool dfs(int i,int j){
     
        if(i==m-1 && j==n-1){
     
            return true;
        }
        int node = grid[i][j];

        
        switch (node) {
     
            case 1:
            {
     
                int x = i,y = j-1;
                if(inArea(x, y)&& toLeft(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
            {
     
                int x = i,y = j+1;
                if(inArea(x, y)&& toRight(grid[x][y])&& !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
                break;
                
            case 2:
            {
     
                int x = i-1,y = j;
                if(inArea(x, y)&& toUp(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
            {
     
                int x = i+1,y = j;
                if(inArea(x, y)&& toDown(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
                break;
                
            case 3:
            {
     
                int x = i+1,y = j;
                if(inArea(x, y)&& toDown(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
            {
     
                int x = i,y = j-1;
                if(inArea(x, y)&& toLeft(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
                break;
                
            case 4:
            {
     
                int x = i+1,y = j;
                if(inArea(x, y)&& toDown(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
            {
     
                int x = i,y = j+1;
                if(inArea(x, y)&& toRight(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
                break;
                
            case 5:
            {
     
                int x = i,y = j-1;
                if(inArea(x, y)&& toLeft(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
            {
     
                int x = i-1,y = j;
                if(inArea(x, y)&& toUp(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
                break;
                
            case 6:
            {
     
                int x = i,y = j+1;
                if(inArea(x, y)&& toRight(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
            {
     
                int x = i-1,y = j;
                if(inArea(x, y)&& toUp(grid[x][y]) && !visited[x][y]){
     
                    visited[x][y] = true;
                    if(dfs(x, y)){
     return true;}
                    visited[x][y] = false;
                }
            }
                break;
                
            default:
                break;
        }
        return false;
    }
    
    bool inArea(int i,int j){
     
        return i>=0 && i<m && j>=0 && j<n;
    }
    
    bool toLeft(int v){
     
        return v==1 || v==4 || v==6;
    }
    
    bool toRight(int v){
     
        return v==1 || v==3 || v==5;
    }
    
    bool toUp(int v){
     
        return v==2 || v==3 || v==4;
    }
    
    bool toDown(int v){
     
        return v==2 || v==5 || v==6;
    }
};

比较精简的写法

(我自己写的太啰嗦了)
大概思想,方向数组按顺序写,比如上右下左,编号为0,1, 2, 3;每种街道的转向都是确定的,都只有两种,也用一个数组记录一下。
最后,根据每种街道类型的不同,依次选择两种方向,得出下一步,但是要判断是否可连接。
+2模4就相当于旋转180度,一种很实用的技巧。

(go[G[x][y]][i]+2)%4 ==go[G[nx][ny]][0] || 
(go[G[x][y]][i]+2)%4==go[G[nx][ny]][1] 
// 上(0) 右(1) 下(2) 左(3)
const int dx[] = {
     -1,0,1,0};
const int dy[] = {
     0,1,0,-1};
//分别对应 6 种街道能转的2种方向,对应编号 0 1 2 3 
const int go[][2] = {
     {
     },{
     1,3},{
     0,2},{
     2,3},{
     1,2},{
     0,3},{
     0,1}};


class Solution {
     
public:
    int m,n;
    vector<vector<int>> G;
    bool visited[310][310] = {
     0};

    bool hasValidPath(vector<vector<int>>& grid) {
     
         G = grid;
         m = grid.size();
         n = grid[0].size();
         memset(visited,0,sizeof(visited));
         return dfs(0,0);
    }

    bool dfs(int x,int y){
     
        visited[x][y] = 1;
        if(x==m-1&&y==n-1){
     
            return true;
        }
        for(int i=0;i<2;i++){
     
            int nx = x + dx[go[G[x][y]][i]];
            int ny = y + dy[go[G[x][y]][i]];
            if( nx>=0&&nx<m&&ny>=0&&ny<n&& !visited[nx][ny] &&
            ((go[G[x][y]][i]+2)%4 ==go[G[nx][ny]][0] || (go[G[x][y]][i]+2)%4==go[G[nx][ny]][1] ) ){
     
                if(dfs(nx,ny)){
     return true;}
                visited[nx][ny] = 0;
            }
        }
        return false;
    }
};

建图+FloodFill

基本原理:
LeetCode 1391. 检查网格中是否存在有效路径 (DFS+并查集)_第2张图片
然后就是一个图的连通性的DFS即可。

const int dx[] = {
     -1,0,1,0};
const int dy[] = {
     0,1,0,-1};
class Solution {
     
public:
    int G[1000][1000],m,n;
    vector<vector<int>> grid;
    bool hasValidPath(vector<vector<int>>& grid) {
     
        this->grid = grid;
        m = grid.size();
        n = grid[0].size();
        memset(G,0,sizeof(G));
        fill(G);

        dfs(1,1);
        return !G[3*m-2][3*n-2];
    }

    void dfs(int x,int y){
     
        G[x][y] = 0;
        for(int i=0;i<4;i++){
     
            int nx = x + dx[i];
            int ny = y + dy[i];
            if(nx>=0&&ny>=0&&nx<3*m&&ny<3*n && G[nx][ny]){
     
                dfs(nx,ny);
            }
        }
    }

    void fill( int(*G)[1000] ){
     
        for(int i=0;i<m;i++){
     
            for(int j=0;j<n;j++){
     
                int v = grid[i][j];
                G[3*i+1][3*j+1]=1;
                if(v==1){
     G[3*i+1][3*j]=G[3*i+1][3*j+2]=1;}
                if(v==2){
     G[3*i][3*j+1]=G[3*i+2][3*j+1]=1;}
                if(v==3){
     G[3*i+1][3*j]=G[3*i+2][3*j+1]=1;}
                if(v==4){
     G[3*i+2][3*j+1]=G[3*i+1][3*j+2]=1;}
                if(v==5){
     G[3*i+1][3*j]=G[3*i][3*j+1]=1;}
                if(v==6){
     G[3*i][3*j+1]=G[3*i+1][3*j+2]=1;}
            }
        }
    }
};

并查集维护图的连通性

首先并查集维护连通性的时候,是通过merge(int x,int y)的方式,这就需要把图中的每一个网格点映射为一个唯一的整数。
这样做即可。

    int getID(int x,int y){
     
        return x*n+y;
    }

那如何判断,某个street可以和另一个street合并呢?
可以仿照一开始的做法。
比如说,1号街道如果想和它左边的街道合并,左边的街道必须是(1 、3、5);如果1号街道想和它右边的街道合并,右边的街道只能是(1、4、6)。
其他街道一样处理。

最后要判断两个点的连通与否,只要看它们的代表元是否相同即可。

const int dx[] = {
     -1,0,1,0};
const int dy[] = {
     0,1,0,-1};


struct UnionFindSet{
     
    int f[300*300+10];
    UnionFindSet(){
     
        for(int i=0;i<300*300;i++){
     
            f[i] = i;
        }
    }
    
    void merge(int x,int y){
     
        f[find(x)] = find(y);
    }
    
    int find(int x){
     
        return x==f[x]?x:f[x]=find(f[x]);
    }
    
};


class Solution {
     
public:
    vector<vector<int>> grid;
    int m,n;
    UnionFindSet ufs;
    
    int getID(int x,int y){
     
        return x*n+y;
    }
    
    bool inArea(int x,int y){
     
        return x>=0&&x<m&&y>=0&&y<n;
    }
    
    void mergeL(int x,int y){
     
        int nx = x,ny = y-1;
        if(inArea(nx, ny)){
     
            int v = grid[nx][ny];
            if(v==1 || v==4 || v==6){
     
                ufs.merge(getID(x, y), getID(nx, ny));
            }
        }
    }
    
    void mergeR(int x,int y){
     
        int nx = x,ny = y+1;
        if(inArea(nx, ny)){
     
            int v = grid[nx][ny];
            if(v==1 || v==3 || v==5){
     
                ufs.merge(getID(x, y), getID(nx, ny));
            }
        }
    }
    
    void mergeU(int x,int y){
     
        int nx = x-1,ny = y;
        if(inArea(nx, ny)){
     
            int v = grid[nx][ny];
            if(v==2 || v==3 || v==4){
     
                ufs.merge(getID(x, y), getID(nx, ny));
            }
        }
    }
    
    void mergeD(int x,int y){
     
        int nx = x+1,ny = y;
        if(inArea(nx, ny)){
     
            int v = grid[nx][ny];
            if(v==2 || v==5 || v==6){
     
                ufs.merge(getID(x, y), getID(nx, ny));
            }
        }
    }
    
    
    bool hasValidPath(vector<vector<int>>& grid) {
     
        this->grid = grid;
        m = (int)grid.size();
        n = (int)grid[0].size();
        
        for(int x=0;x<m;x++){
     
            for(int y=0;y<n;y++){
     
                int kind = grid[x][y];
                switch (kind) {
     
                    case 1:
                        mergeL(x, y);mergeR(x, y);
                        break;
                        
                    case 2:
                        mergeU(x, y);mergeD(x, y);
                        break;
                        
                    case 3:
                        mergeL(x, y);mergeD(x, y);
                        break;
                        
                    case 4:
                        mergeR(x, y);mergeD(x, y);
                        break;
                        
                    case 5:
                        mergeL(x, y);mergeU(x, y);
                        break;
                        
                    case 6:
                        mergeR(x, y);mergeU(x, y);
                        break;
                    default:
                        break;
                }
            }
        }
        return ufs.find(getID(0, 0))==ufs.find(getID(m-1, n-1));
    }
};

你可能感兴趣的:(LeetCode,#,LC深度优先搜索)