【算法与数据结构】827、LeetCode最大人工岛

所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。

一、题目

二、解法

  思路分析：本题暴力解法是用遍历每个网格的方式，将0改成1，然后用深搜计算岛屿最大面积。遍历每个网格的复杂度为$n\times n$，深搜的复杂度为$n\times n$。总的时间复杂度为$O(n^4)$。其实在每次做深度搜索遍历计算最大岛屿面积的时候都做了很多重复工作，只需要用一次深搜把每个岛屿面积记录下来就好。然后第二次遍历0的网格，将其改成1，将其相邻的岛屿面积相加。具体做法如下：

• 第一次遍历地图：得出岛屿面积，用map记录，key为岛屿编号，value为岛屿面积。
• 第二次遍历地图：遍历0网格，将其相邻面积相加。在遍历完所有0网格以后可以得到一个最大面积。

  程序如下：

// 827、最大人工岛-深度优先搜索
class Solution {
private:
	int maxArea = 0;		// 最终输出的最大面积
	bool isallisland = true;
	unordered_map<int, int> gridArea;	
	int Area = 0;	// 面积计数器
	vector<vector<int>> delta_x_y = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };	// 上下左右四个方向的偏移量
	void dfs(vector<vector<int>>& grid, int x, int y, int mark) {	// 1、递归输入参数
		// 2、终止条件 遇到海水或者遍历过
		if (grid[x][y] == 0 || grid[x][y] != 1) return;
		grid[x][y] = mark;	// 给陆地上标签
		Area++;
		// 3、单层递归逻辑
		for (int i = 0; i < 4; i++) {
			int nextx = x + delta_x_y[i][0];
			int nexty = y + delta_x_y[i][1];
			if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 越界了或者遍历过，直接跳过 
			dfs(grid, nextx, nexty, mark);
		}
	}
public:
	int largestIsland(vector<vector<int>>& grid) {
		vector<vector<bool>> visited = vector<vector<bool>>(grid.size(), vector<bool>(grid[0].size(), false));	// 遍历过的坐标
		int mark = 2;	// 记录岛屿编号，作为gridArea的key值，可以是大于1的任意数字		
		// 统计岛屿面积
		for (int i = 0; i < grid.size(); i++) {	// 遍历行
			for (int j = 0; j < grid[0].size(); j++) {	// 遍历列
				if (grid[i][j] == 1) {
					Area = 0;
					dfs(grid, i, j, mark);	// 深度优先搜索，将连接的陆地都标记上true
					gridArea[mark] = Area;		// 记录每一个岛屿的面积
					mark++;
				}
				if (grid[i][j] == 0) isallisland = false;
			}
		}
		if (isallisland) return grid.size() * grid.size();
		// 遍历所有0格点
		
		unordered_set<int> visitedGrid; // 标记访问过的岛屿
		for (int i = 0; i < grid.size(); i++) {	// 遍历行
			for (int j = 0; j < grid[0].size(); j++) {	// 遍历列
				Area = 1;
				visitedGrid.clear();		// 每次使用需要清空
				if (grid[i][j] == 0) {
					for (int k = 0; k < 4; k++) {
						int nextx = i + delta_x_y[k][0];
						int nexty = j + delta_x_y[k][1];
						if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 越界了，直接跳过 
						if (visitedGrid.count(grid[nextx][nexty])) continue; // 添加过的岛
						Area += gridArea[grid[nextx][nexty]];
						visitedGrid.insert(grid[nextx][nexty]);	// 标记该岛屿已经添加过
					}
				}
				maxArea = max(maxArea, Area);
			}
		}
		return maxArea;
	}
};

复杂度分析：

• 时间复杂度：$O(n^2)$。主程序当中用到了四个for循环，复杂度为$O(n^2+n^2)=O(n^2)$
• 空间复杂度：$O(n^2)$。

三、完整代码

# include <iostream>
# include <vector>
# include <unordered_map>
# include <unordered_set>
using namespace std;

// 827、最大人工岛-深度优先搜索
class Solution {
private:
	int maxArea = 0;		// 最终输出的最大面积
	bool isallisland = true;
	unordered_map<int, int> gridArea;	
	int Area = 0;	// 面积计数器
	vector<vector<int>> delta_x_y = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };	// 上下左右四个方向的偏移量
	void dfs(vector<vector<int>>& grid, int x, int y, int mark) {	// 1、递归输入参数
		// 2、终止条件 遇到海水或者遍历过
		if (grid[x][y] == 0 || grid[x][y] != 1) return;
		grid[x][y] = mark;	// 给陆地上标签
		Area++;
		// 3、单层递归逻辑
		for (int i = 0; i < 4; i++) {
			int nextx = x + delta_x_y[i][0];
			int nexty = y + delta_x_y[i][1];
			if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 越界了或者遍历过，直接跳过 
			dfs(grid, nextx, nexty, mark);
		}
	}
public:
	int largestIsland(vector<vector<int>>& grid) {
		vector<vector<bool>> visited = vector<vector<bool>>(grid.size(), vector<bool>(grid[0].size(), false));	// 遍历过的坐标
		int mark = 2;	// 记录岛屿编号，作为gridArea的key值，可以是大于1的任意数字		
		// 统计岛屿面积
		for (int i = 0; i < grid.size(); i++) {	// 遍历行
			for (int j = 0; j < grid[0].size(); j++) {	// 遍历列
				if (grid[i][j] == 1) {
					Area = 0;
					dfs(grid, i, j, mark);	// 深度优先搜索，将连接的陆地都标记上true
					gridArea[mark] = Area;		// 记录每一个岛屿的面积
					mark++;
				}
				if (grid[i][j] == 0) isallisland = false;
			}
		}
		if (isallisland) return grid.size() * grid.size();
		// 遍历所有0格点
		
		unordered_set<int> visitedGrid; // 标记访问过的岛屿
		for (int i = 0; i < grid.size(); i++) {	// 遍历行
			for (int j = 0; j < grid[0].size(); j++) {	// 遍历列
				Area = 1;
				visitedGrid.clear();		// 每次使用需要清空
				if (grid[i][j] == 0) {
					for (int k = 0; k < 4; k++) {
						int nextx = i + delta_x_y[k][0];
						int nexty = j + delta_x_y[k][1];
						if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;  // 越界了，直接跳过 
						if (visitedGrid.count(grid[nextx][nexty])) continue; // 添加过的岛
						Area += gridArea[grid[nextx][nexty]];
						visitedGrid.insert(grid[nextx][nexty]);	// 标记该岛屿已经添加过
					}
				}
				maxArea = max(maxArea, Area);
			}
		}
		return maxArea;
	}
};

int main() {
	//vector<vector<int>> grid = { {0, 0}, {0, 0} };
	vector<vector<int>> grid = { {0, 0, 0, 0, 0, 0, 0}, {0, 1, 1, 1, 1, 0, 0}, {0, 1, 0, 0, 1, 0, 0}, {1, 0, 1, 0, 1, 0, 0}, {0, 1, 0, 0, 1, 0, 0},{0, 1, 0, 0, 1, 0, 0},{0, 1, 1, 1, 1, 0, 0} };
	Solution s1;
	int result = s1.largestIsland(grid);
	cout << "最大岛屿面积为：" << result << endl;
	system("pause");
	return 0;
}

end