在网格中查找循环(Java)

public class GridCycleFinder {
    private boolean[][] visited;
    private int[][] grid;
    private int rows;
    private int cols;

    public boolean hasCycle(int[][] grid) {
        this.grid = grid;
        this.rows = grid.length;
        this.cols = grid[0].length;
        this.visited = new boolean[rows][cols];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (!visited[i][j] && dfs(i, j, -1, -1)) {
                    return true;
                }
            }
        }

        return false;
    }

    private boolean dfs(int row, int col, int prevRow, int prevCol) {
        if (row < 0 || row >= rows || col < 0 || col >= cols || visited[row][col]) {
            return false;
        }

        visited[row][col] = true;

        int currValue = grid[row][col];

        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        for (int[] dir : directions) {
            int newRow = row + dir[0];
            int newCol = col + dir[1];

            if (newRow == prevRow && newCol == prevCol) {
                continue; // Skip the previous cell
            }

            if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols && grid[newRow][newCol] == currValue) {
                if (visited[newRow][newCol] || dfs(newRow, newCol, row, col)) {
                    return true;
                }
            }
        }

        visited[row][col] = false; // Reset the visited flag
        return false;
    }
}