岛屿的最大面积
题目描述
给你一个大小为 m x n 的二进制矩阵 grid 。
岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
岛屿的面积是岛上值为 1 的单元格的数目。
计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。
问题分析
程序代码
cpp
class Solution {
private:
vector<int> dx = {-1, 0, 1, 0};
vector<int> dy = {0, -1, 0, 1};
int dfs(vector<vector<int>>& grid, vector<vector<bool>>& st, int r, int c) {
// 已经遍历过，直接返回
if( st[r][c] ) return 0;
int n = grid.size(), m = grid[0].size();
int res = 1;
st[r][c] = true;
for(int i = 0; i < 4; i++) {
int x = r + dx[i], y = c + dy[i];
if(x >= 0 && x < n && y >= 0 && y < m && grid[x][y] == 1 && !st[x][y]) {
res += dfs(grid, st, x, y);
}
}
return res;
}
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
int n = grid.size();
if(n == 0) return 0;
int m = grid[0].size();
vector<vector<bool>> st(n, vector<bool>(m, false));
int res = 0;
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
if(grid[i][j] == 1 && !st[i][j]) {
res = max(res, dfs(grid, st, i, j));
}
}
}
return res;
}
};复杂度分析
时间复杂度为 O ( N M ) O(NM) O(NM)
最大人工岛
题目描述
给你一个大小为 n x n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。
返回执行此操作后，grid 中最大的岛屿面积是多少？
岛屿 由一组上、下、左、右四个方向相连的 1 形成。
问题分析
为了方便实现并查集，将二维坐标转换为一维上的点，计算公式为idx = x * n + y
使用并查集维护所有grid[i][j] = 1的块连通性，并在维护连通性的过程种，使用sz[idx]记录下每个连通块的大小。
对原始的grid[i][j]进行处理：
- 若
grid[i][j] = 1，无需变为岛屿。直接计算连通块的最大面积sz[root]，其中root为(i, j)所属连通块的根节点编号。 - 若
grid[i][j] = 0，该位置可变为岛屿，统计四个方向连通位置是否存在岛屿，计算连通后的岛屿总和。
最后，对所有连通块大小取最大值。
程序代码
cpp
class Solution {
private:
int n;
vector<int> p; // 并查集
vector<int> sz; // 连通块的大小
vector<int> dx = {-1, 0, 1, 0};
vector<int> dy = {0, -1, 0, 1};
// 将二维坐标转换为一维上的点
int get(int x, int y) {
return x * n + y;
}
// 并查集查找操作
int find(int x) {
if(p[x] != x) p[x] = find(p[x]);
return p[x];
}
public:
int largestIsland(vector<vector<int>>& grid) {
n = grid.size();
if(n == 0) return 0;
p = vector<int>(n * n, 0);
sz = vector<int>(n * n, 1); // 连通块大小初始化为1
for(int i = 0; i < n * n; i++) {
p[i] = i;
}
// 计算岛屿变化前的连通块大小
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
if( grid[i][j] == 0) continue;
int a = get(i, j);
// 遍历四个方向，计算连通块大小
for(int t = 0; t < 4; t++) {
int x = i + dx[t], y = j + dy[t];
if(x < 0 || x >= n || y < 0 || y >= n || grid[x][y] == 0) continue;
int b = get(x, y);
int pa = find(a), pb = find(b);
// 已经连通
if(pa == pb) {
continue;
}
// 集合合并
p[pb] = pa;
sz[pa] += sz[pb];
}
}
}
int res = 0;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
int a = get(i, j);
if(grid[i][j] == 1) {
res = max(res, sz[find(a)]);
}
else {
int ans = 1;
unordered_set<int> s;
// 扩展四个方向的连通分量
for(int t = 0; t < 4; t++) {
int x = i + dx[t], y = j + dy[t];
if(x < 0 || x >= n || y < 0 || y >= n || grid[x][y] == 0) continue;
int b = get(x, y);
int pb = find(b);
// 该连通分量已经扩展过了
if( s.count(pb) ) continue;
ans += sz[pb];
s.insert(pb);
}
res = max(res, ans);
}
}
}
return res;
}
};复杂度分析
时间复杂度为 O ( N 2 ) O(N^2) O(N2)