Leetcode 827. Making A Large Island

Problem:

 

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.

 

Solution:

　　Hard题中的easy题，首先用一个哈希表chunk用每个联通块根节点映射该联通块对应的大小，用Union Find即可，然后对于grid中每个值为0的位置，若其上下左右某个位置为1，则找到该位置对应的根节点，在chunk中找到其对于的联通块的大小，加到square中即可，注意有可能上下左右四个方位中的某些1是联通的，所以我在循环内部用了一个哈希集root记录了访问过的根节点避免重复相加联通块。注意边界即可。

Code:

 

class Solution {
public:
    int Find(vector<int> &parent,int target){
        while(parent[target] != target){
            target = parent[target];
        }
        return target;
    }
    void Union(vector<int> &parent,int x,int y){
        int px = Find(parent,x);
        int py = Find(parent,y);
        if(px == py) return;
        if(px < py) 
            parent[py] = px;
        else 
            parent[px] = py;
    }
    int largestIsland(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector<int> parent(m*n,0);
        vector<vector<int>> dir({{0,1},{0,-1},{1,0},{-1,0}});
        for(int i = 0;i != m*n;++i){
            parent[i] = i;
        }
        for(int i = 0;i != m;++i){
            for(int j = 0;j != n;++j){
                if(grid[i][j] == 0) continue;
                for(int k = 0;k != dir.size();++k){
                    if(i+dir[k][0] < 0 || i+dir[k][0] >= m || j+dir[k][1] < 0 || j+dir[k][1] >= n)
                        continue;
                    if(grid[i+dir[k][0]][j+dir[k][1]] == 1)
                        Union(parent,i*n+j,(i+dir[k][0])*n+j+dir[k][1]);
                }
            }
        }
        int maximal = 0;
        unordered_map<int,int> chunk;
        for(int i = 0;i != m;++i){
            for(int j = 0;j != n;++j){
                if(grid[i][j] == 0) continue;
                int root = Find(parent,i*n+j);
                chunk[root]++;
                maximal = max(maximal,chunk[root]);
            }
        }
        for(int i = 0;i != m;++i){
            for(int j = 0;j != n;++j){
                if(grid[i][j] == 1) continue;
                int square = 1;
                unordered_set<int> root;
                for(int k = 0;k != dir.size();++k){
                    if(i+dir[k][0] < 0 || i+dir[k][0] >= m || j+dir[k][1] < 0 || j+dir[k][1] >= n)
                        continue;
                    if(grid[i+dir[k][0]][j+dir[k][1]] == 1){
                        int r = Find(parent,(i+dir[k][0])*n+j+dir[k][1]);
                        if(root.find(r) == root.end()){
                            root.insert(r);
                            square += chunk[r];
                        }
                    }
                }
                maximal = max(maximal,square);
            }
        }
        return maximal;
    }
};