【Leetcode】1559. Detect Cycles in 2D Grid

题目地址：

https://leetcode.com/problems/detect-cycles-in-2d-grid/

给定一个$m\times n$的字符矩阵，问是否存在一个回路，使得这个回路的路径上都是同一个字符。回路里每一步只能上下左右走一格。

思路是并查集。将每个格子视为顶点，如果某两个相邻的格子字符相同，则视为连一条边。那么如果这个图存在回路，就可以直接返回true。只需要遍历每条边，当连边的时候两个顶点已经连通，则说明回路存在。可以用并查集来判断两个点是否连通。代码如下：

public class Solution {
    class UnionFind {
        int[] p;
        
        UnionFind(int size) {
            p = new int[size];
            for (int i = 0; i < size; i++) {
                p[i] = i;
            }
        }
        
        int find(int x) {
            if (p[x] != x) {
                p[x] = find(p[x]);
            }
            
            return p[x];
        }
        
        boolean union(int x, int y) {
            int px = find(x), py = find(y);
            if (px != py) {
                p[px] = py;
                return true;
            }
            
            return false;
        }
    }
    
    public boolean containsCycle(char[][] grid) {
        int m = grid.length, n = grid[0].length;
        UnionFind uf = new UnionFind(m * n);
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                char ch = grid[i][j];
                int x = get(i, j, n);
                // 如果能连边，并且边的两个端点已经连通，则说明存在回路，返回true
                if (i + 1 < m && grid[i + 1][j] == ch) {
                    if (!uf.union(x, get(i + 1, j, n))) {
                        return true;
                    }
                }
                
                if (j + 1 < n && grid[i][j + 1] == ch) {
                    if (!uf.union(x, get(i, j + 1, n))) {
                        return true;
                    }
                }
            }
        }
        
        return false;
    }
    
    int get(int x, int y, int n) {
        return x * n + y;
    }
}

时间复杂度$O(mn{\log }^{\ast }mn)$，空间$O(mn)$。