[LeetCode] 827. Making A Large Island

In a 2D grid of 0s and 1s, we change at most one 0 to a 1.

After, what is the size of the largest island? (An island is a 4-directionally connected group of 1s).

Example 1:

Input: [[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: [[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: [[1, 1], [1, 1]]
Output: 4
Explanation: Can't change any 0 to 1, only one island with area = 4.

Notes:

• 1 <= grid.length = grid[0].length <= 50.
• 0 <= grid[i][j] <= 1.

这个题目我只能想到naive的做法, T: O((m*n)^2), 就是对每个 grid[i][j] == 0 的元素, 将其换为1, 然后用BFS来计算size, 一直循环, 找最大值, 如果没有0 的话返回m*n.

然后参考了这个T: O(m*n) 的做法. 思路就是最开始将grid扫一遍, 每次如果grid[i][j] == 1, 将该点及所有跟它相连的为1 的点, 标记为color, 然后将各个不同的island tag为不同颜色, 并且用d2来存color和这个color的island 的size, 思路和做法跟[LeetCode] 200. Number of Islands_ Medium tag: BFS一样, 只是需要标记color.

这样之后可以得到如上图所示的结果, 然后再将grid扫一遍, 这一次是针对 grid[i][j] == 0 的元素, 然后看四个邻居是否为1, 如果是的话将它的size加入到temp里面,只是要注意的是有可能同样颜色的可以是多个neig, 所以要用set来排除已经加入同样颜色的size了, 最后返回最大值即可.

1. Constraints

1) size of grid, [1*1] ~ [50*50]

2) element will only be 0 or 1

2. Ideas

DFS/BFS    用BFS,      T: O(m*n)     S: O(m*n)

3. Code

 class Solution:
     def largestIsland(self, grid):
         def bfs(grid, d1, i, j, d2, dirs, color):
             lr, lc, d1[(i, j)], queue, size = len(grid), len(grid[0]), color, collections.deque([(i,j)]), 1

             while queue:
                 pr, pc = queue.popleft()
                 for c1, c2 in dirs:
                     nr, nc = c1 + pr , c2 + pc
                     if 0 <= nr < lr and 0 <= nc < lc and (nr, nc) not in d1:
                         d1[(nr, nc)] = color
                         queue.append((nr, nc))
                         size += 1
             d2[color] = size
         d1, d2, lr, lc , dirs, temp, color = {},{}, len(grid), len(grid[0]), [(0,1), (0,-1), (1, 0), (-1,0)], -1, 1
         for i in range(lr):
             for j in range(lc):
                 if grid[i][j] == 1 and (i,j) not in d1:
                     color += 1
                     bfs(grid, d1, i, j, d2, dirs, color)

         for i in range(lr):
             for j in range(lc):
                 if grid[i][j] == 0:
                     colors = set()
                     for c1, c2 in dirs:
                         nr, nc = i+ c1, j + c2
                         if 0 <= nr < lr and 0 <= nc < lc and grid[nr][nc] == 1:
                             colors.add(d1[nr][nc])
                     s = sum(d2[color] for color in colors) + 1
                     temp = s if temp == -1 else max(temp, s)
         return temp if temp != -1 else lr*lc

2)

class Solution(object):
    def largestIsland(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        lr, lc, dirs, colorMap, ans, colorSize, queue, curColor = len(grid), len(grid[0]), [(1, 0), (-1, 0), (0, 1), (0, -1)], {}, 0, {}, collections.deque(), 0
        # color all the islands and save the pos -> color in colorMap, color -> size in colorSize
        for i in range(lr):
            for j in range(lc):
                if grid[i][j] == 1 and (i, j) not in colorMap:
                    size = 0
                    curColor += 1
                    queue.append((i, j))
                    colorMap[(i, j)] = curColor
                    while queue:
                        r, c = queue.popleft()
                        size += 1
                        for d1, d2 in dirs:
                            nr, nc = r + d1, c + d2
                            if 0 <= nr < lr and 0 <= nc < lc and (nr, nc) not in colorMap and grid[nr][nc] == 1:
                                queue.append((nr, nc))
                                colorMap[(nr, nc)] = curColor
                    colorSize[curColor] = size
                    ans = max(ans, size)

        #### to each i, j that grid[i][j] == 0 , put all neigbours that is 1 and add all the color in a set, sum all color sizes and max(ans, sizeSum)
        for i in range(lr):
            for j in range(lc):
                if grid[i][j] == 0:
                    colorSet = set()
                    for d1, d2 in dirs:
                        nr, nc = i + d1, j + d2
                        if 0 <= nr < lr and 0 <= nc < lc and grid[nr][nc] == 1:
                            colorSet.add(colorMap[(nr, nc)])
                    ans = max(ans, 1 + sum(colorSize[color] for color in colorSet))
        return ans