# 5 Best Ways to Check for Cycles in a Matrix Using Python

Rate this post

π‘ Problem Formulation: This article explores algorithms that determine if a given set of elements in a matrix form a cycle. In the context of a two-dimensional grid (matrix), a cycle is formed if there’s a path that starts and ends at the same cell, and travels only between adjacent cells (horizontally or vertically). For example, given a matrix, a cycle detection algorithm might input a starting point and the matrix itself, with the desired output being a boolean value indicating whether a cycle exists.

## Method 1: Depth-First Search (DFS)

Depth-First Search (DFS) is a classic graph traversal algorithm that can be used to detect cycles in a matrix by exploring as far as possible along each branch before backtracking. This method checks for visited nodes to determine if a cell has been encountered before, which indicates the presence of a cycle. The algorithm can be implemented recursively or iteratively.

Here’s an example:

```def dfs(matrix, i, j, visited=None, parent=None):
if visited is None:
visited = set()
if (i, j) in visited:
return True
rows, cols = len(matrix), len(matrix[0])
directions = [(0, 1), (1, 0), (-1, 0), (0, -1)]
for dir in directions:
next_i, next_j = i + dir[0], j + dir[1]
if (0 <= next_i < rows and 0 <= next_j < cols and
matrix[next_i][next_j] == matrix[i][j] and
(next_i, next_j) != parent):
if dfs(matrix, next_i, next_j, visited, (i, j)):
return True
return False

matrix = [
[1, 2, 3],
[4, 1, 6],
[4, 5, 1]
]

print(dfs(matrix, 0, 0))
```

Output: `False`

This code snippet defines a DFS function which checks for cycles starting from a given cell in the matrix. It uses a `visited` set to keep track of already visited cells and a `parent` variable to avoid returning to the previous cell, as it does not constitute a cycle. In this example, it starts searching from the top-left cell `(0, 0)` and goes through adjacent cells of the same value. The output `False` suggests that there’s no cycle starting from the initial cell.

## Method 2: Union-Find Algorithm

The Union-Find algorithm is a data structure that is efficient for disjoint-set manipulations; it can be used to maintain a collection of non-overlapping sets and is particularly effective in cycle detection in a graph. Each cell in the matrix represents an element in a set, union by rank and path compression are used to optimize the tree structure that represents the sets.

Here’s an example:

```class UnionFind:
def __init__(self, size):
self.parent = list(range(size))
self.rank = [0] * size

def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]

def union(self, x, y):
rootX = self.find(x)
rootY = self.find(y)
if rootX != rootY:
if self.rank[rootX] > self.rank[rootY]:
self.parent[rootY] = rootX
elif self.rank[rootX] < self.rank[rootY]:
self.parent[rootX] = rootY
else:
self.parent[rootY] = rootX
self.rank[rootX] += 1

def matrix_to_sets(matrix):
rows, cols = len(matrix), len(matrix[0])
uf = UnionFind(rows * cols)
for i in range(rows):
for j in range(cols - 1):
if matrix[i][j] == matrix[i][j + 1]:
uf.union(i * cols + j, i * cols + j + 1)
if i < rows - 1 and matrix[i][j] == matrix[i + 1][j]:
uf.union(i * cols + j, (i + 1) * cols + j)
return uf

matrix = [
[1, 2, 3],
[4, 1, 2],
[1, 5, 2]
]

uf = matrix_to_sets(matrix)
print("Cycle Detected" if uf.find(0) == uf.find(8) else "No Cycle Detected")
```

Output: `No Cycle Detected`

The `UnionFind` class represents a union-find data structure. The `matrix_to_sets` function converts the matrix into disjoint sets where each cell is initially in its own set. Cells with the same value and adjacent to each other are merged into the same set. If the start and end cell have the same root in the union-find structure, a cycle is detected. In this case, no cycle is detected as cells `(0,0)` and `(2,2)` do not have the same root.

## Method 3: Breadth-First Search (BFS)

Breadth-First Search (BFS) can be applied to detect cycles in a matrix similar to the depth-first approach but explores all neighbors level by level. It leverages a queue data structure to explore each cell and its neighbors and uses a visited set to keep track of cells that have been added to the queue to avoid processing a cell more than once.

Here’s an example:

```from collections import deque

def bfs_cycle_check(matrix, start):
visited = set()
queue = deque([start])
while queue:
i, j = queue.popleft()
if (i, j) in visited:
return True
for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
ni, nj = i+di, j+dj
if 0 <= ni < len(matrix) and 0 <= nj < len(matrix[0]):
if matrix[ni][nj] == matrix[i][j] and (ni, nj) not in visited:
queue.append((ni, nj))
return False

matrix = [
[1, 2, 3],
[4, 1, 6],
[4, 5, 1]
]

print(bfs_cycle_check(matrix, (0, 0)))
```

Output: `False`

This snippet implements a BFS-based cycle detection algorithm. It starts with the given `start` cell, then uses a queue to process all cells at the current level before moving on to their neighbors. If a cell is visited more than once, it implies a cycle. The output `False` indicates that from the initial starting point, the algorithm did not discover any cycle.

## Method 4: Floyd’s Tortoise and Hare

Popularized for cycle detection in linked lists, Floyd’s Tortoise and Hare algorithm can also be adapted for cycle detection in matrices. Also known as the cycle detection algorithm, it uses two pointers moving at different speeds to find a cycle. If they meet, a cycle exists.

Here’s an example:

```def floyds(matrix, start):
tortoise = hare = start
while True:
tortoise = next_cell(matrix, tortoise)
hare = next_cell(matrix, next_cell(matrix, hare))
if hare is None or tortoise is None:
return False
if hare == tortoise:
return True

def next_cell(matrix, cell):
i, j = cell
for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
ni, nj = i+di, j+dj
if 0 <= ni < len(matrix) and 0 <= nj < len(matrix[0]):
if matrix[ni][nj] == matrix[i][j]:
return (ni, nj)
return None

matrix = [
[1, 2, 3],
[4, 1, 2],
[1, 5, 2]
]

print(floyds(matrix, (0, 0)))
```

Output: `False`

This code applies Floyd’s Tortoise and Hare algorithm to a matrix. Here, both tortoise and hare start at a designated `start` cell and move through the matrix to adjacent cells with the same value. The hare moves two steps for every step the tortoise takes. If a cycle is present, the hare and tortoise will eventually land on the same cell, indicating a cycle.

## Bonus One-Liner Method 5: Simple Recursive Check

A one-liner recursive solution could be constructed by applying Python’s powerful list comprehension and any() function for cycle detection, combined with a modified DFS approach.

Here’s an example:

```detect_cycle = lambda i, j, matrix, v=set(): (i, j) in v or v.add((i, j)) or any(detect_cycle(i+di, j+dj, matrix, v) for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)] if 0 <= i+di < len(matrix) and 0 <= j+dj < len(matrix[0]) and matrix[i+di][j+dj] == matrix[i][j])

matrix = [
[1, 2, 3],
[4, 1, 2],
[1, 5, 2]
]

print(detect_cycle(0, 0, matrix))
```

Output: `False`

This one-liner defines a lambda function which employs recursion and the `any()` function to traverse the matrix from the starting cell and detect cycles. It uses a set `v` to keep track of visited cells. The lambda checks whether the current cell has been visited; if not, it explores neighboring cells with the same value. The output `False` indicates that there is no cycle from the starting point.

## Summary/Discussion

• Method 1: Depth-First Search (DFS). Strengths: Simple logic, recursive approach is natural. Weaknesses: Recursive DFS can hit recursion limits on large inputs, and it can be slower for dense graphs.
• Method 2: Union-Find Algorithm. Strengths: Very efficient for large and sparse matrices, amortized constant time operations. Weaknesses: Higher complexity, not as intuitive, requires additional space for data structure.
• Method 3: Breadth-First Search (BFS). Strengths: Iterative approach avoids recursion limit issues, good for finding shortest path cycle. Weaknesses: Can be slower than DFS if the cycle is not near the starting point.
• Method 4: Floyd’s Tortoise and Hare. Strengths: No extra space required, guaranteed to find a cycle if one exists. Weaknesses: Determining the entry point of the cycle is complex, not straightforward to apply.
• Bonus One-Liner Method 5: Simple Recursive Check. Strengths: Concise code, good for small matrices. Weaknesses: Can easily hit recursion limits, not recommended for large matrices.