827. Making A Large Island

Description

You are given an n x n binary matrix grid. You are allowed to change at most one 0 to be 1.

Return the size of the largest island in grid after applying this operation.

An island is a 4-directionally connected group of 1s.

 

Example 1:

Input: grid = [[1,0],[0,1]]
Output: 3
Explanation: Change one 0 to 1 and connect two 1s, then we get an island with area = 3.

Example 2:

Input: grid = [[1,1],[1,0]]
Output: 4
Explanation: Change the 0 to 1 and make the island bigger, only one island with area = 4.

Example 3:

Input: grid = [[1,1],[1,1]]
Output: 4
Explanation: Can't change any 0 to 1, only one island with area = 4.

 

Constraints:

• n == grid.length
• n == grid[i].length
• 1 <= n <= 500
• grid[i][j] is either 0 or 1.

 

Solutions

Solution: Depth-First Search

• Time complexity: O(n²)
• Space complexity: O(n²)

 

JavaScript

/**
 * @param {number[][]} grid
 * @return {number}
 */
const largestIsland = function (grid) {
  const n = grid.length;

  const getGroupArea = (row, col, group) => {
    if (row >= n || col >= n || row < 0 || col < 0) return 0;
    if (grid[row][col] !== 1) return 0;

    grid[row][col] = group;

    const leftArea = getGroupArea(row, col - 1, group);
    const rightArea = getGroupArea(row, col + 1, group);
    const upperArea = getGroupArea(row - 1, col, group);
    const lowerArea = getGroupArea(row + 1, col, group);

    return 1 + leftArea + rightArea + upperArea + lowerArea;
  };
  const groupMap = new Map();
  let group = 2;

  for (let row = 0; row < n; row++) {
    for (let col = 0; col < n; col++) {
      if (grid[row][col] !== 1) continue;
      const area = getGroupArea(row, col, group);

      groupMap.set(group, area);
      group += 1;
    }
  }
  let result = 0;

  for (let row = 0; row < n; row++) {
    for (let col = 0; col < n; col++) {
      if (grid[row][col] !== 0) continue;
      const leftGroup = grid[row][col - 1];
      const rightGroup = grid[row][col + 1];
      const upperGroup = grid[row - 1]?.[col];
      const lowerGroup = grid[row + 1]?.[col];
      const groups = new Set([leftGroup, rightGroup, upperGroup, lowerGroup]);
      let area = 1;

      for (const group of groups) {
        area += groupMap.get(group) ?? 0;
      }
      result = Math.max(area, result);
    }
  }
  return result ? result : n * n;
};