feat: add solutions to lc problem: No.1559 (doocs#3558)

No.1559.Detect Cycles in 2D Grid

Author: yanglbme

solution/1500-1599/1559.Detect Cycles in 2D Grid/README.md

@@ -1,28 +1,39 @@
-class Solution {
-public:
-    vector<int> p;
-
-    bool containsCycle(vector<vector<char>>& grid) {
-        int m = grid.size(), n = grid[0].size();
-        p.resize(m * n);
-        for (int i = 0; i < p.size(); ++i) p[i] = i;
-        vector<int> dirs = {0, 1, 0};
-        for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                for (int k = 0; k < 2; ++k) {
-                    int x = i + dirs[k], y = j + dirs[k + 1];
-                    if (x < m && y < n && grid[x][y] == grid[i][j]) {
-                        if (find(x * n + y) == find(i * n + j)) return 1;
-                        p[find(x * n + y)] = find(i * n + j);
-                    }
-                }
-            }
-        }
-        return 0;
-    }
-
-    int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
-        return p[x];
-    }
-};
+class Solution {
+public:
+    bool containsCycle(vector<vector<char>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        vector<vector<bool>> vis(m, vector<bool>(n));
+        const vector<int> dirs = {-1, 0, 1, 0, -1};
+
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (!vis[i][j]) {
+                    queue<array<int, 4>> q;
+                    q.push({i, j, -1, -1});
+                    vis[i][j] = true;
+
+                    while (!q.empty()) {
+                        auto p = q.front();
+                        q.pop();
+                        int x = p[0], y = p[1], px = p[2], py = p[3];
+
+                        for (int k = 0; k < 4; ++k) {
+                            int nx = x + dirs[k], ny = y + dirs[k + 1];
+                            if (nx >= 0 && nx < m && ny >= 0 && ny < n) {
+                                if (grid[nx][ny] != grid[x][y] || (nx == px && ny == py)) {
+                                    continue;
+                                }
+                                if (vis[nx][ny]) {
+                                    return true;
+                                }
+                                q.push({nx, ny, x, y});
+                                vis[nx][ny] = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+};

solution/1500-1599/1559.Detect Cycles in 2D Grid/README_EN.md

@@ -1,29 +1,38 @@
-func containsCycle(grid [][]byte) bool {
-	m, n := len(grid), len(grid[0])
-	p := make([]int, m*n)
-	for i := range p {
-		p[i] = i
-	}
-	var find func(x int) int
-	find = func(x int) int {
-		if p[x] != x {
-			p[x] = find(p[x])
-		}
-		return p[x]
-	}
-	dirs := []int{1, 0, 1}
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			for k := 0; k < 2; k++ {
-				x, y := i+dirs[k], j+dirs[k+1]
-				if x < m && y < n && grid[x][y] == grid[i][j] {
-					if find(x*n+y) == find(i*n+j) {
-						return true
-					}
-					p[find(x*n+y)] = find(i*n + j)
-				}
-			}
-		}
-	}
-	return false
-}
+func containsCycle(grid [][]byte) bool {
+	m, n := len(grid), len(grid[0])
+	vis := make([][]bool, m)
+	for i := range vis {
+		vis[i] = make([]bool, n)
+	}
+	dirs := []int{-1, 0, 1, 0, -1}
+
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if !vis[i][j] {
+				q := [][]int{{i, j, -1, -1}}
+				vis[i][j] = true
+
+				for len(q) > 0 {
+					p := q[0]
+					q = q[1:]
+					x, y, px, py := p[0], p[1], p[2], p[3]
+
+					for k := 0; k < 4; k++ {
+						nx, ny := x+dirs[k], y+dirs[k+1]
+						if nx >= 0 && nx < m && ny >= 0 && ny < n {
+							if grid[nx][ny] != grid[x][y] || (nx == px && ny == py) {
+								continue
+							}
+							if vis[nx][ny] {
+								return true
+							}
+							q = append(q, []int{nx, ny, x, y})
+							vis[nx][ny] = true
+						}
+					}
+				}
+			}
+		}
+	}
+	return false
+}

solution/1500-1599/1559.Detect Cycles in 2D Grid/Solution.cpp

@@ -1,35 +1,34 @@
-class Solution {
-    private int[] p;
-
-    public boolean containsCycle(char[][] grid) {
-        int m = grid.length;
-        int n = grid[0].length;
-        p = new int[m * n];
-        for (int i = 0; i < p.length; ++i) {
-            p[i] = i;
-        }
-        int[] dirs = {0, 1, 0};
-        for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                for (int k = 0; k < 2; ++k) {
-                    int x = i + dirs[k];
-                    int y = j + dirs[k + 1];
-                    if (x < m && y < n && grid[i][j] == grid[x][y]) {
-                        if (find(x * n + y) == find(i * n + j)) {
-                            return true;
-                        }
-                        p[find(x * n + y)] = find(i * n + j);
-                    }
-                }
-            }
-        }
-        return false;
-    }
-
-    private int find(int x) {
-        if (p[x] != x) {
-            p[x] = find(p[x]);
-        }
-        return p[x];
-    }
-}
+class Solution {
+    public boolean containsCycle(char[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        boolean[][] vis = new boolean[m][n];
+        final int[] dirs = {-1, 0, 1, 0, -1};
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (!vis[i][j]) {
+                    Deque<int[]> q = new ArrayDeque<>();
+                    q.offer(new int[] {i, j, -1, -1});
+                    vis[i][j] = true;
+                    while (!q.isEmpty()) {
+                        int[] p = q.poll();
+                        int x = p[0], y = p[1], px = p[2], py = p[3];
+                        for (int k = 0; k < 4; ++k) {
+                            int nx = x + dirs[k], ny = y + dirs[k + 1];
+                            if (nx >= 0 && nx < m && ny >= 0 && ny < n) {
+                                if (grid[nx][ny] != grid[x][y] || (nx == px && ny == py)) {
+                                    continue;
+                                }
+                                if (vis[nx][ny]) {
+                                    return true;
+                                }
+                                q.offer(new int[] {nx, ny, x, y});
+                                vis[nx][ny] = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

solution/1500-1599/1559.Detect Cycles in 2D Grid/Solution.go

@@ -3,26 +3,28 @@
  * @return {boolean}
  */
 var containsCycle = function (grid) {
-    const m = grid.length;
-    const n = grid[0].length;
-    let p = Array.from({ length: m * n }, (_, i) => i);
-    function find(x) {
-        if (p[x] != x) {
-            p[x] = find(p[x]);
-        }
-        return p[x];
-    }
-    const dirs = [0, 1, 0];
-    for (let i = 0; i < m; ++i) {
-        for (let j = 0; j < n; ++j) {
-            for (let k = 0; k < 2; ++k) {
-                const x = i + dirs[k];
-                const y = j + dirs[k + 1];
-                if (x < m && y < n && grid[x][y] == grid[i][j]) {
-                    if (find(x * n + y) == find(i * n + j)) {
-                        return true;
+    const [m, n] = [grid.length, grid[0].length];
+    const vis = Array.from({ length: m }, () => Array(n).fill(false));
+    const dirs = [-1, 0, 1, 0, -1];
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (!vis[i][j]) {
+                const q = [[i, j, -1, -1]];
+                vis[i][j] = true;
+                for (const [x, y, px, py] of q) {
+                    for (let k = 0; k < 4; k++) {
+                        const [nx, ny] = [x + dirs[k], y + dirs[k + 1]];
+                        if (nx >= 0 && nx < m && ny >= 0 && ny < n) {
+                            if (grid[nx][ny] !== grid[x][y] || (nx === px && ny === py)) {
+                                continue;
+                            }
+                            if (vis[nx][ny]) {
+                                return true;
+                            }
+                            q.push([nx, ny, x, y]);
+                            vis[nx][ny] = true;
+                        }
                     }
-                    p[find(x * n + y)] = find(i * n + j);
                 }
             }
         }

solution/1500-1599/1559.Detect Cycles in 2D Grid/Solution.java

@@ -1,18 +1,23 @@
-class Solution:
-    def containsCycle(self, grid: List[List[str]]) -> bool:
-        def find(x):
-            if p[x] != x:
-                p[x] = find(p[x])
-            return p[x]
-
-        m, n = len(grid), len(grid[0])
-        p = list(range(m * n))
-        for i in range(m):
-            for j in range(n):
-                for a, b in [[0, 1], [1, 0]]:
-                    x, y = i + a, j + b
-                    if x < m and y < n and grid[x][y] == grid[i][j]:
-                        if find(x * n + y) == find(i * n + j):
-                            return True
-                        p[find(x * n + y)] = find(i * n + j)
-        return False
+class Solution:
+    def containsCycle(self, grid: List[List[str]]) -> bool:
+        m, n = len(grid), len(grid[0])
+        vis = [[False] * n for _ in range(m)]
+        dirs = (-1, 0, 1, 0, -1)
+        for i, row in enumerate(grid):
+            for j, x in enumerate(row):
+                if vis[i][j]:
+                    continue
+                vis[i][j] = True
+                q = [(i, j, -1, -1)]
+                while q:
+                    x, y, px, py = q.pop()
+                    for dx, dy in pairwise(dirs):
+                        nx, ny = x + dx, y + dy
+                        if 0 <= nx < m and 0 <= ny < n:
+                            if grid[nx][ny] != grid[i][j] or (nx == px and ny == py):
+                                continue
+                            if vis[nx][ny]:
+                                return True
+                            vis[nx][ny] = True
+                            q.append((nx, ny, x, y))
+        return False

solution/1500-1599/1559.Detect Cycles in 2D Grid/Solution.js

@@ -1,56 +1,41 @@
-impl Solution {
-    #[allow(dead_code)]
-    pub fn contains_cycle(grid: Vec<Vec<char>>) -> bool {
-        let n = grid.len();
-        let m = grid[0].len();
-        let mut d_set: Vec<usize> = vec![0; n * m];
-
-        // Initialize the disjoint set
-        for i in 0..n * m {
-            d_set[i] = i;
-        }
-
-        // Traverse the grid
-        for i in 0..n {
-            for j in 0..m {
-                if i + 1 < n && grid[i + 1][j] == grid[i][j] {
-                    // Check the below cell
-                    let p_curr = Self::find(i * m + j, &mut d_set);
-                    let p_below = Self::find((i + 1) * m + j, &mut d_set);
-                    if p_curr == p_below {
-                        return true;
-                    }
-                    // Otherwise, union the two cells
-                    Self::union(p_curr, p_below, &mut d_set);
-                }
-                // Same to the right cell
-                if j + 1 < m && grid[i][j + 1] == grid[i][j] {
-                    let p_curr = Self::find(i * m + j, &mut d_set);
-                    let p_right = Self::find(i * m + (j + 1), &mut d_set);
-                    if p_curr == p_right {
-                        return true;
-                    }
-                    // Otherwise, union the two cells
-                    Self::union(p_curr, p_right, &mut d_set);
-                }
-            }
-        }
-
-        false
-    }
-
-    #[allow(dead_code)]
-    fn find(x: usize, d_set: &mut Vec<usize>) -> usize {
-        if d_set[x] != x {
-            d_set[x] = Self::find(d_set[x], d_set);
-        }
-        d_set[x]
-    }
-
-    #[allow(dead_code)]
-    fn union(x: usize, y: usize, d_set: &mut Vec<usize>) {
-        let p_x = Self::find(x, d_set);
-        let p_y = Self::find(y, d_set);
-        d_set[p_x] = p_y;
-    }
-}
+impl Solution {
+    pub fn contains_cycle(grid: Vec<Vec<char>>) -> bool {
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut vis = vec![vec![false; n]; m];
+        let dirs = vec![-1, 0, 1, 0, -1];
+
+        for i in 0..m {
+            for j in 0..n {
+                if !vis[i][j] {
+                    let mut q = vec![(i as isize, j as isize, -1, -1)];
+                    vis[i][j] = true;
+
+                    while !q.is_empty() {
+                        let (x, y, px, py) = q.pop().unwrap();
+
+                        for k in 0..4 {
+                            let nx = x + dirs[k];
+                            let ny = y + dirs[k + 1];
+                            if nx >= 0 && nx < m as isize && ny >= 0 && ny < n as isize {
+                                let nx = nx as usize;
+                                let ny = ny as usize;
+                                if grid[nx][ny] != grid[x as usize][y as usize]
+                                    || (nx == px as usize && ny == py as usize)
+                                {
+                                    continue;
+                                }
+                                if vis[nx][ny] {
+                                    return true;
+                                }
+                                q.push((nx as isize, ny as isize, x, y));
+                                vis[nx][ny] = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        false
+    }
+}