Detect Cycles in 2D Grid

Detect Cycles in 2D Grid - Problem

Given a 2D array of characters grid of size m x n, you need to find if there exists any cycle consisting of the same value in grid.

A cycle is a path of length 4 or more in the grid that starts and ends at the same cell. From a given cell, you can move to one of the cells adjacent to it - in one of the four directions (up, down, left, or right), if it has the same value of the current cell.

Also, you cannot move to the cell that you visited in your last move. For example, the cycle (1, 1) -> (1, 2) -> (1, 1) is invalid because from (1, 2) we visited (1, 1) which was the last visited cell.

Return true if any cycle of the same value exists in grid, otherwise, return false.

Input & Output

Example 1 — Basic Cycle

$ Input: grid = [["a","b","b"],["a","a","b"],["a","a","a"]]

› Output: true

💡 Note: There is a cycle with same value 'a': (0,0) → (1,0) → (1,1) → (2,1) → (2,2) → (2,0) → back to (0,0)

Example 2 — No Cycle

$ Input: grid = [["c","c","c","a"],["c","d","c","c"],["c","c","e","c"],["f","c","c","c"]]

› Output: false

💡 Note: No cycles exist in this grid. Each connected component of same characters forms a tree structure

Example 3 — Small Cycle

$ Input: grid = [["a","a"],["a","a"]]

› Output: true

💡 Note: Simple 2x2 square forms a cycle: (0,0) → (0,1) → (1,1) → (1,0) → back to (0,0)

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 500
grid consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 f Meta 31 M Microsoft 29

The key insight is that a cycle exists when we visit a cell that's already been visited and is not our immediate parent. The optimal approach uses DFS with parent tracking to efficiently detect cycles by exploring each connected component once. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Brute Force - Try All Paths

⏱️ Time: O(4^(m×n)) Space: O(m×n)

For each cell, try all possible paths of increasing length using backtracking. Check if any path forms a cycle by returning to the starting position with length ≥ 4.

DFS with Parent Tracking

⏱️ Time: O(m×n) Space: O(m×n)

For each unvisited cell, start DFS and mark cells as visited. If we reach a visited cell that is not the immediate parent, we found a cycle.

Union-Find (Disjoint Set Union)

⏱️ Time: O(m×n×α(m×n)) Space: O(m×n)

Convert the grid to a graph problem. For each cell with same adjacent character, union them. If we try to union two cells already in same component, there's a cycle.

Brute Force - Try All Paths — Algorithm Steps

Start from every cell in the grid
Use backtracking to generate all paths of same characters
For each path, check if it returns to start with length ≥ 4

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Cell

Begin DFS from each cell in the grid

Explore Paths

Try all 4 directions recursively with same character

Check Cycle

Return true if any path returns to start with length ≥ 4

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

static char grid[505][505];
static bool visited[505][505];

bool dfs(int x, int y, int parentX, int parentY, char ch, int m, int n) {
    visited[x][y] = true;
    
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    for (int i = 0; i < 4; i++) {
        int nx = x + directions[i][0], ny = y + directions[i][1];
        if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] == ch) {
            if (nx == parentX && ny == parentY) {
                continue;
            }
            if (visited[nx][ny]) {
                return true;
            }
            if (dfs(nx, ny, x, y, ch, m, n)) {
                return true;
            }
        }
    }
    return false;
}

bool solution(int m, int n) {
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = false;
        }
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (!visited[i][j]) {
                if (dfs(i, j, -1, -1, grid[i][j], m, n)) {
                    return true;
                }
            }
        }
    }
    return false;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int m = 0, n = 0;
    int i = 0;
    
    // Find first '['
    while (line[i] && line[i] != '[') i++;
    if (line[i]) i++; // skip first '['
    
    while (line[i] && line[i] != '\n' && line[i] != '\0') {
        if (line[i] == '[') {
            i++; // skip '['
            n = 0;
            while (line[i] && line[i] != ']') {
                if (line[i] == '"') {
                    i++; // skip '"'
                    if (line[i] && line[i] != '"') {
                        grid[m][n] = line[i];
                        n++;
                        i++; // skip the character
                    }
                    if (line[i] == '"') i++; // skip closing '"'
                } else {
                    i++;
                }
            }
            if (line[i] == ']') i++; // skip ']'
            if (n > 0) m++;
        } else {
            i++;
        }
    }
    
    bool result = solution(m, n);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m×n))

For each cell, we try 4 directions recursively up to m×n depth

✓ Linear Growth

Space Complexity

O(m×n)

Recursion stack can go up to m×n depth in worst case

⚡ Linearithmic Space

34.5K Views

Medium-High Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler