二维网格图中探测环

/*
 * The goal is to check if there's a cycle formed by the same character in a 2D grid using Java Streams.
 * While Java Streams are not typically used for DFS, we will still leverage lambdas and functional interfaces for a more modern approach.
 */

import java.util.function.BiFunction;

public class Solution {
    private int rows, cols;
    private char[][] grid;
    private boolean[][] visited;
    private final int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

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

        BiFunction<Integer, Integer, Boolean> dfs = new BiFunction<>() {
            @Override
            public Boolean apply(Integer x, Integer y) {
                if (visited[x][y]) {
                    return length >= 4;
                }
                visited[x][y] = true;
                for (int[] dir : directions) {
                    int nx = x + dir[0], ny = y + dir[1];
                    if (nx >= 0 && ny >= 0 && nx < rows && ny < cols && !(nx == px && ny == py) && grid[nx][ny] == ch) {
                        if (dfs.apply(nx, ny)) {
                            return true;
                        }
                    }
                }
                visited[x][y] = false;
                return false;
            }
        };

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