Introduction

In this blog post, we will explore how to solve the LeetCode problem "1559" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

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. Example 1: Input: grid = [["a","a","a","a"],["a","b","b","a"],["a","b","b","a"],["a","a","a","a"]] Output: true Explanation: There are two valid cycles shown in different colors in the image below: Example 2: Input: grid = [["c","c","c","a"],["c","d","c","c"],["c","c","e","c"],["f","c","c","c"]] Output: true Explanation: There is only one valid cycle highlighted in the image below: Example 3: Input: grid = [["a","b","b"],["b","z","b"],["b","b","a"]] Output: false Constraints: m == grid.length n == grid[i].length 1 <= m, n <= 500 grid consists only of lowercase English letters.

Explanation

Here's a breakdown of the solution:

• DFS for Cycle Detection: We'll use Depth First Search (DFS) to explore the grid. The core idea is to traverse the grid, and if we encounter the same cell we started from (and the path length is at least 4), we've found a cycle.

• Keeping Track of the Parent: To avoid immediately backtracking to the cell we just came from, we'll maintain a 'parent' cell during the DFS traversal. This prevents invalid cycles of length 2.

• Visited Array: Use a visited array to keep track of all the visited cells for efficient cycle detection.

• Complexity:

  • Runtime: O(m * n), where 'm' is the number of rows and 'n' is the number of columns in the grid. We potentially visit each cell once.
  • Space: O(m * n) for the visited array and the recursion stack in the worst-case scenario.

Code

    def containsCycle(grid):
    m = len(grid)
    n = len(grid[0])
    visited = [[False] * n for _ in range(m)]

    def dfs(row, col, parent_row, parent_col, start_char):
        if row < 0 or row >= m or col < 0 or col >= n or grid[row][col] != start_char:
            return False

        if visited[row][col]:
            return True

        visited[row][col] = True

        # Explore neighbors
        directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        for dr, dc in directions:
            new_row, new_col = row + dr, col + dc
            if (new_row, new_col) != (parent_row, parent_col):
                if dfs(new_row, new_col, row, col, start_char):
                    return True

        return False

    for i in range(m):
        for j in range(n):
            if not visited[i][j]:
                if dfs(i, j, -1, -1, grid[i][j]):
                    return True

    return False