island Archives - Huahua's Tech Road

花花酱 LeetCode 1905. Count Sub Islands

zxi — Sun, 15 Aug 2021 22:42:04 +0000

You are given two m x n binary matrices grid1 and grid2 containing only 0‘s (representing water) and 1‘s (representing land). An island is a group of 1‘s connected 4-directionally (horizontal or vertical). Any cells outside of the grid are considered water cells.

An island in grid2 is considered a sub-island if there is an island in grid1 that contains all the cells that make up this island in grid2.

Return the number of islands in grid2 that are considered sub-islands.

Example 1:

Input: grid1 = [[1,1,1,0,0],[0,1,1,1,1],[0,0,0,0,0],[1,0,0,0,0],[1,1,0,1,1]], grid2 = [[1,1,1,0,0],[0,0,1,1,1],[0,1,0,0,0],[1,0,1,1,0],[0,1,0,1,0]]
Output: 3
Explanation: In the picture above, the grid on the left is grid1 and the grid on the right is grid2.
The 1s colored red in grid2 are those considered to be part of a sub-island. There are three sub-islands.

Example 2:

Input: grid1 = [[1,0,1,0,1],[1,1,1,1,1],[0,0,0,0,0],[1,1,1,1,1],[1,0,1,0,1]], grid2 = [[0,0,0,0,0],[1,1,1,1,1],[0,1,0,1,0],[0,1,0,1,0],[1,0,0,0,1]]
Output: 2 
Explanation: In the picture above, the grid on the left is grid1 and the grid on the right is grid2.
The 1s colored red in grid2 are those considered to be part of a sub-island. There are two sub-islands.

Constraints:

m == grid1.length == grid2.length
n == grid1[i].length == grid2[i].length
1 <= m, n <= 500
grid1[i][j] and grid2[i][j] are either 0 or 1.

Solution: Coloring

Give each island in grid1 a different color. Whiling using the same method to find island and coloring it in grid2, we also check whether the same cell in grid1 always has the same color.

Time complexity: O(mn)
Space complexity: O(1) modify in place or O(mn)

C++

// Author: Huahua
class Solution {
public:
  int countSubIslands(vector>& grid1, vector>& grid2) {
    const int m = grid1.size();
    const int n = grid1[0].size();
    int valid = 1;
    
    function color = [&](int i, int j, int c, int p) {
      if (i < 0 || i >= m || j < 0 || j >= n) return;
      auto& gc = p ? grid2 : grid1;
      auto& go = p ? grid1 : grid2;
      if (gc[i][j] != 1) return;
      gc[i][j] = c;
      if (p && go[i][j] != c) valid = 0;
      color(i + 1, j, c, p);
      color(i - 1, j, c, p);
      color(i, j + 1, c, p);
      color(i, j - 1, c, p);
    };
        
    for (int i = 0, c = 2; i < m; ++i)
      for (int j = 0; j < n; ++j)
        if (grid1[i][j] == 1) color(i, j, c++, 0);
    
    int ans = 0;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        if (grid2[i][j] == 1 && grid1[i][j]) {
          valid = 1;
          color(i, j, grid1[i][j], 1);
          ans += valid;
        }    
    return ans;
  }
};

The post 花花酱 LeetCode 1905. Count Sub Islands appeared first on Huahua's Tech Road.

花花酱 LeetCode 1254. Number of Closed Islands

zxi — Sun, 10 Nov 2019 06:38:30 +0000

Given a 2D grid consists of 0s (land) and 1s (water). An island is a maximal 4-directionally connected group of 0s and a closed island is an island totally (all left, top, right, bottom) surrounded by 1s.

Return the number of closed islands.

Example 1:

Input: grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
Output: 2
Explanation: 
Islands in gray are closed because they are completely surrounded by water (group of 1s).

Example 2:

Input: grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
Output: 1

Example 3:

Input: grid = [[1,1,1,1,1,1,1],
               [1,0,0,0,0,0,1],
               [1,0,1,1,1,0,1],
               [1,0,1,0,1,0,1],
               [1,0,1,1,1,0,1],
               [1,0,0,0,0,0,1],
               [1,1,1,1,1,1,1]]
Output: 2

Constraints:

1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1

Solution: DFS/Backtracking

For each connected component, if it can reach the boundary then it’s not a closed island.

Time complexity: O(n*m)
Space complexity: O(n*m)

C++

// Author: Huahua
class Solution {
public:
  int closedIsland(vector>& grid) {    
    const int n = grid.size();
    const int m = grid[0].size();    
    function dfs = [&](int x, int y) {
      if (x < 0 || y < 0 || x >= m || y >= n) return 0;      
      if (grid[y][x]++) return 1;
      return dfs(x + 1, y) & dfs(x - 1, y) & dfs(x, y + 1) & dfs(x, y - 1);
    };
    
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < m; ++j)
        if (!grid[i][j]) ans += dfs(j, i);      
    return ans;
  }
};

The post 花花酱 LeetCode 1254. Number of Closed Islands appeared first on Huahua's Tech Road.

花花酱 LeetCode 947. Most Stones Removed with Same Row or Column

zxi — Fri, 30 Nov 2018 05:06:23 +0000

Problem

On a 2D plane, we place stones at some integer coordinate points. Each coordinate point may have at most one stone.

Now, a move consists of removing a stone that shares a column or row with another stone on the grid.

What is the largest possible number of moves we can make?

Example 1:

Input: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
Output: 5

Example 2:

Input: stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
Output: 3

Example 3:

Input: stones = [[0,0]]
Output: 0

Note:

1 <= stones.length <= 1000
0 <= stones[i][j] < 10000

Solution 2: Union Find

Find all connected components (islands)

Ans = # of stones – # of islands

C++

// Author: Huahua, running time: 16 ms
class Solution {
public:
  int removeStones(vector>& stones) {
    const int kSize = 10000;
    DSU dsu(kSize * 2);
    for (const auto& stone : stones)
      dsu.Union(stone[0], stone[1] + kSize);
    unordered_set seen;
    for (const auto& stone : stones)
      seen.insert(dsu.Find(stone[0]));
    return stones.size() - seen.size();
  }
private:
  class DSU {
  public:
    DSU(int n): p_(n) {
      for (int i = 0 ; i < n; ++i)
        p_[i] = i;              
    }
    
    void Union(int i, int j) {
      p_[Find(i)] = Find(j);      
    }
    
    int Find(int i) {
      if (p_[i] != i) p_[i] = Find(p_[i]);
      return p_[i];
    }    
  private:
    vector p_;    
  };
};

花花酱 LeetCode 200. Number of Islands

zxi — Thu, 21 Sep 2017 02:23:43 +0000

Problem:

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

Answer: 1

Example 2:

Idea: DFS

Use DFS to find a connected component (an island) and mark all the nodes to 0.

Time complexity: O(mn)

Space complexity: O(mn)

Solution

C++

// Author: Huahua
// Time complexity: O(mn)
// Running time: 6 ms
class Solution {
public:
    int numIslands(vector>& grid) {
        if (grid.empty()) return 0;
        int m = grid.size();
        int n = grid[0].size();
        int ans = 0;
        for (int y = 0; y < m; ++y)
            for (int x = 0; x < n; ++x) {
                ans += grid[y][x] - '0';
                dfs(grid, x, y, m, n);
            }
        return ans;                
    }   
private:
    void dfs(vector>& grid, int x, int y, int m, int n) {
        if (x < 0 || y < 0 || x >= n || y >= m || grid[y][x] == '0')
            return;
        grid[y][x] = '0';
        dfs(grid, x + 1, y, m, n);
        dfs(grid, x - 1, y, m, n);
        dfs(grid, x, y + 1, m, n);
        dfs(grid, x, y - 1, m, n);
    }
};

Java

// Author: Huahua
// Time Complexity: O(mn)
// Running time: 13 ms
class Solution {
    public int numIslands(char[][] grid) {
        int m = grid.length;
        if (m == 0) return 0;
        int n = grid[0].length;
        
        int ans = 0;
        for (int y = 0; y < m; ++y)
            for (int x = 0; x < n; ++x)
                if (grid[y][x] == '1') {
                    ++ans;
                    dfs(grid, x, y, n, m);
                }
        
        return ans;
    }
    
    private void dfs(char[][] grid, int x, int y, int n, int m) {
        if (x < 0 || y < 0 || x >= n || y >= m || grid[y][x] == '0')
            return;
        grid[y][x] = '0';
        dfs(grid, x + 1, y, n, m);
        dfs(grid, x - 1, y, n, m);
        dfs(grid, x, y + 1, n, m);
        dfs(grid, x, y - 1, n, m);
    }
}

Python

"""
Author: Huahua
Time Complexity: O(mn)
Running Time: 102 ms
"""
class Solution(object):
    def numIslands(self, grid):
        """
        :type grid: List[List[str]]
        :rtype: int
        """
        m = len(grid)
        if m == 0: return 0
        n = len(grid[0])
        
        ans = 0
        for y in xrange(m):
            for x in xrange(n):
                if grid[y][x] == '1':
                    ans += 1
                    self.__dfs(grid, x, y, n, m)
        return ans
    
    def __dfs(self, grid, x, y, n, m):
        if x < 0 or y < 0 or x >=n or y >= m or grid[y][x] == '0':
            return
        grid[y][x] = '0'
        self.__dfs(grid, x + 1, y, n, m)
        self.__dfs(grid, x - 1, y, n, m)
        self.__dfs(grid, x, y + 1, n, m)
        self.__dfs(grid, x, y - 1, n, m)

island Archives - Huahua's Tech Road

花花酱 LeetCode 1905. Count Sub Islands

Solution: Coloring

C++

花花酱 LeetCode 1254. Number of Closed Islands

Solution: DFS/Backtracking

C++

花花酱 LeetCode 947. Most Stones Removed with Same Row or Column

Problem

Solution 2: Union Find

C++

Related Problems

花花酱 LeetCode 200. Number of Islands

Idea: DFS

Solution

C++

Java

Python

Related Problems