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)

// Author: Huahua
class Solution {
public:
  int countSubIslands(vector<vector<int>>& grid1, vector<vector<int>>& grid2) {
    const int m = grid1.size();
    const int n = grid1[0].size();
    int valid = 1;
    
    function<void(int, int, int, int)> 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.

The rank is an integer that represents how large an element is compared to other elements. It is calculated using the following rules:

• The rank is an integer starting from 1.
• If two elements p and q are in the same row or column, then:
  • If p < q then rank(p) < rank(q)
  • If p == q then rank(p) == rank(q)
  • If p > q then rank(p) > rank(q)
• The rank should be as small as possible.

It is guaranteed that answer is unique under the given rules.

Example 1:

Input: matrix = [[1,2],[3,4]]
Output: [[1,2],[2,3]]
Explanation:
The rank of matrix[0][0] is 1 because it is the smallest integer in its row and column.
The rank of matrix[0][1] is 2 because matrix[0][1] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][0] is 2 because matrix[1][0] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][1] is 3 because matrix[1][1] > matrix[0][1], matrix[1][1] > matrix[1][0], and both matrix[0][1] and matrix[1][0] are rank 2.

Example 2:

Input: matrix = [[7,7],[7,7]]
Output: [[1,1],[1,1]]

Example 3:

Input: matrix = [[20,-21,14],[-19,4,19],[22,-47,24],[-19,4,19]]
Output: [[4,2,3],[1,3,4],[5,1,6],[1,3,4]]

Example 4:

Input: matrix = [[7,3,6],[1,4,5],[9,8,2]]
Output: [[5,1,4],[1,2,3],[6,3,1]]

Constraints:

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 500
• -109 <= matrix[row][col] <= 109

Solution: Union Find

Group cells by their values, process groups (cells that have the same value) in ascending order (smaller number has smaller rank).

For cells that are in the same row and same cols union them using union find, they should have the same rank which equals to max(max_rank_x[cols], max_rank_y[rows]) + 1.

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

// Author: Huahua
class DSU {
public:
  DSU(int n): p_(n, -1) {}
  int find(int x) {
    return p_[x] == -1 ? x : p_[x] = find(p_[x]);
  }  
  void merge(int x, int y) {
    x = find(x), y = find(y);
    if (x != y) p_[x] = y;    
  }
private:
  vector<int> p_;
};

class Solution {
public:
  vector<vector<int>> matrixRankTransform(vector<vector<int>>& matrix) {
    const int m = matrix.size();
    const int n = matrix[0].size();
    vector<vector<int>> ans(m, vector<int>(n));
    map<int, vector<pair<int, int>>> mp; // val -> {positions}
    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        mp[matrix[y][x]].emplace_back(x, y);
    vector<int> rx(n), ry(m);
    for (const auto& [val, ps]: mp) {
      DSU dsu(n + m);
      vector<vector<pair<int, int>>> cc(n + m); // val -> {positions}
      for (const auto& [x, y]: ps)
        dsu.merge(x, y + n);
      for (const auto& [x, y]: ps)        
        cc[dsu.find(x)].emplace_back(x, y);      
      for (const auto& ps: cc) {
        int rank = 1;
        for (const auto& [x, y]: ps)
          rank = max(rank, max(rx[x], ry[y]) + 1);
        for (const auto& [x, y]: ps)
          rx[x] = ry[y] = ans[y][x] = rank;   
      }      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1632. Rank Transform of a Matrix appeared first on Huahua's Tech Road.