Max Area of Island - Largest in Boolean Matrix

// Java Program to find area of the largest region of 1s

import java.util.*;

class GfG {
  	
    // A function to check if cell(r, c) can be included in DFS
    static boolean isSafe(int[][] M, int r, int c, int rows, int cols) {
        // row number is in range, column number is in range and
        // value is 1 
        return (r >= 0 && r < rows) && (c >= 0 && c < cols) && (M[r][c] == 1);
    }

    // Depth-First-Search to visit all cells in the current island
    static void DFS(int[][] M, int r, int c, int rows, int cols, int[] area) {
      	
        // These arrays are used to get row and column
        // numbers of 8 neighbours of a given cell
        int[] dirR = {-1, -1, -1, 0, 0, 1, 1, 1};
        int[] dirC = {-1, 0, 1, -1, 1, -1, 0, 1};

        // Increment area of region by 1
        area[0] += 1;

        // Mark this cell as visited
        M[r][c] = 0;

        // Recur for all connected neighbours
        for (int i = 0; i < 8; i++) {
            int newR = r + dirR[i];
            int newC = c + dirC[i];

            if (isSafe(M, newR, newC, rows, cols)) {
                DFS(M, newR, newC, rows, cols, area);
            }
        }
    }

    // function to find area of the largest region of 1s
    static int largestRegion(int[][] M) {
        int rows = M.length;
        int cols = M[0].length;

        // Initialize result as 0 and traverse through the
        // all cells of given matrix
        int maxArea = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                // If a cell with value 1 is found
                if (M[i][j] == 1) {
                  
                  	// area is taken as an array of size 1 to 
                  	// achieve pass by reference 
                    int[] area = {0};
                    DFS(M, i, j, rows, cols, area);

                    // maximize the area 
                    maxArea = Math.max(maxArea, area[0]);
                }
            }
        }
        return maxArea;
    }

    public static void main(String[] args) {
        int[][] M = {
            {1, 0, 0, 0, 1, 0, 0},
            {0, 1, 0, 0, 1, 1, 1},
            {1, 1, 0, 0, 0, 0, 0},
            {1, 0, 0, 1, 1, 0, 0},
            {1, 0, 0, 1, 0, 1, 1}
        };

        System.out.println(largestRegion(M));
    }
}

// Java Program to find area of the largest region of 1s

import java.util.LinkedList;
import java.util.Queue;

public class GfG {

    // A function to check if cell(r, c) can be included in BFS
    static boolean isSafe(int[][] M, int r, int c, int rows, int cols) {
        // row number is in range, column number is in range and
        // value is 1
        return (r >= 0 && r < rows) && (c >= 0 && c < cols) && (M[r][c] == 1);
    }

    // Breadth-First-Search to visit all cells in the current island
    static int BFS(int[][] M, int r, int c, int rows, int cols) {
        // These arrays are used to get row and column
        // numbers of 8 neighbours of a given cell
        int[] dirR = {-1, -1, -1, 0, 0, 1, 1, 1};
        int[] dirC = {-1, 0, 1, -1, 1, -1, 0, 1};

        int area = 0;

        // Create a queue for BFS traversal
        Queue<int[]> q = new LinkedList<>();

        // Push the cell(r, c) into queue and mark it as visited
        q.add(new int[]{r, c});
        M[r][c] = 0;
        
        while (!q.isEmpty()) {
            int[] curr = q.poll();
            int currR = curr[0];
            int currC = curr[1];
            
            // Increment the area of region
            area += 1;

            // Recur for all 8 connected neighbours
            for (int i = 0; i < 8; i++) {
                int newR = currR + dirR[i];
                int newC = currC + dirC[i];

                if (isSafe(M, newR, newC, rows, cols)) {
                    M[newR][newC] = 0;
                    q.add(new int[]{newR, newC});
                }
            }
        }
        return area;
    }

    // Function to find area of the largest region of 1s
    static int largestRegion(int[][] M) {
        int rows = M.length;
        int cols = M[0].length;

        // Initialize result as 0 and traverse through the
        // all cells of given matrix
        int maxArea = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                
                // If a cell with value 1 is found
                if (M[i][j] == 1) {
                    int area = BFS(M, i, j, rows, cols);

                    // Maximize the area 
                    maxArea = Math.max(maxArea, area);
                }
            }
        }
        return maxArea;
    }

    public static void main(String[] args) {
        int[][] M = {
            {1, 0, 0, 0, 1, 0, 0},
            {0, 1, 0, 0, 1, 1, 1},
            {1, 1, 0, 0, 0, 0, 0},
            {1, 0, 0, 1, 1, 0, 0},
            {1, 0, 0, 1, 0, 1, 1}
        };

        System.out.println(largestRegion(M));
    }
}