【leetcode】【2022/9/18】827. 最大人工岛

问题描述：

• 给定一个大小为 n * n 二进制矩阵 grid，最多只能将一格 0 变成 1，返回执行此操作后 grid 中最大的岛屿面积。
  • 岛屿由一组上、下、左、右四个方向相连的 1 形成。

核心思路：

• 该题是典型的并查集问题，将相邻的值为 1 的格子连通起来（即并查集的 union 操作）。
• 因此维护一个并查集（with size）来解题。
  • 首先创建一个具有 size 数组的并查集，遍历二维网格，遇到值为 1 的格子时，把它和四周值为 1 的格子进行 union 操作即可。
  • 初始化完之后，再重新遍历一次，遇到值为 0 的格子时，寻找它四个方向上值为 1 的格子各自有多少的size（即记录该格子的 parent 与 size[parent]）。【用哈希表来存，可以去重】【存完之后，把哈希表中的 size 值加起来再加上 1 即可，加上 1 就是相当于把当前的 0 格子转为值为 1】【在整个过程中比较获得最大值即可】
• 该题考察的东西比较直观，代码虽然较长，但是本身难度并不大，因为它只有一次把 0 变为 1 的机会（评论区有人说某为机试把题目改成了有两次修改格子的机会）。
  • 该题仍然可以用 dfs 来做，和并查集解法其实比较类似，先一次深度搜索确定岛屿的编号以及用哈希表记录岛屿的面积，然后再一次遍历网格尝试将某个方格置 1。

代码实现：

class DSU // 并查集 with size
{
public:
    vector<int> parent;
    vector<int> size;
    DSU(int N) : parent(N), size(N, 1)
    {
        for(int i = 0; i < N; ++i) parent[i] = i;
    }
    int _find(int x) // 找root
    {
        if(parent[x] != x) parent[x] = _find(parent[x]);
        return parent[x];
    }
    void _union(int x, int y)
    {
        // parent[_find(x)] = _find(y);
        int px = _find(x), py = _find(y);
        if(px == py) return;
        if(size[px] <= size[py])
        {
            parent[px] = py;
            size[py] += size[px];
        }
        else
        {
            parent[py] = px;
            size[px] += size[py];
        }
        return;
    }
};

class Solution
{
public:
    int largestIsland(vector<vector<int>>& grid)
    {
        int m = grid.size(), n = grid[0].size();
        DSU* dsu = new DSU(m*n);
        int ans = 0;
        for(int i = 0; i < m; ++i) for(int j = 0; j < n; ++j) if(grid[i][j] == 1)
        {
            if(i-1 >= 0 and grid[i-1][j] == 1) dsu->_union((i-1)*n+j, i*n+j);
            if(j-1 >= 0 and grid[i][j-1] == 1) dsu->_union(i*n+j-1, i*n+j);
            if(i+1 < m and grid[i+1][j] == 1) dsu->_union((i+1)*n+j, i*n+j);
            if(j+1 < n and grid[i][j+1] == 1) dsu->_union(i*n+j+1, i*n+j);
            ans = max(ans, dsu->size[dsu->_find(i*n+j)]);
        }
        for(int i = 0; i < m; ++i) for(int j = 0; j < n; ++j) if(grid[i][j] == 0)
        {
            unordered_map<int, int> mp;
            int parent;
            if(i-1 >= 0 and grid[i-1][j] == 1)
            {
                parent = dsu->_find((i-1)*n+j);
                mp[parent] = dsu->size[parent];
            }
            if(j-1 >= 0 and grid[i][j-1] == 1)
            {
                parent = dsu->_find(i*n+j-1);
                mp[parent] = dsu->size[parent];
            }
            if(i+1 < m and grid[i+1][j] == 1)
            {
                parent = dsu->_find((i+1)*n+j);
                mp[parent] = dsu->size[parent];
            }
            if(j+1 < n and grid[i][j+1] == 1)
            {
                parent = dsu->_find(i*n+j+1);
                mp[parent] = dsu->size[parent];
            }
            int tmp = 1;
            for(auto& [_, b] : mp)
                tmp += b;
            ans = max(ans, tmp);
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81