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

题目（图的静态连通性）

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

1 表示连接左单元格和右单元格的街道。
2 表示连接上单元格和下单元格的街道。
3 表示连接左单元格和下单元格的街道。
4 表示连接右单元格和下单元格的街道。
5 表示连接左单元格和上单元格的街道。
6 表示连接右单元格和上单元格的街道。

你最开始从左上角的单元格 (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

基本原理：

然后就是一个图的连通性的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));
    }
};