1.岛屿数量深搜
卡码网题目链接（ACM模式）(opens new window)
题目描述：
给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。
输入描述：
第一行包含两个整数 N, M，表示矩阵的行数和列数。
后续 N 行，每行包含 M 个数字，数字为 1 或者 0。
输出描述：
输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。
输入示例：
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1
输出示例：
3
提示信息
根据测试案例中所展示，岛屿数量共有 3 个，所以输出 3。
数据范围：
- 1 <= N, M <= 50
思路
注意题目中每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
也就是说斜角度链接是不算了， 例如示例二，是三个岛屿，如图：
这道题题目是 DFS，BFS，并查集，基础题目。
本题思路，是用遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。
在遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。
那么如何把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。
深度优先搜索
使用dfs实现，如果对dfs不太了解的话，建议按照代码随想录的讲解顺序学习。
可能有疑惑，为什么 以上代码中的dfs函数，没有终止条件呢？ 感觉递归没有终止很危险。
其实终止条件 就写在了 调用dfs的地方，如果遇到不合法的方向，直接不会去调用dfs。
区别了，无疑就是版本一中 调用dfs 的条件判断 放在了 版本二 的 终止条件位置上。
版本一的写法是 ：下一个节点是否能合法已经判断完了，传进dfs函数的就是合法节点。
版本二的写法是：不管节点是否合法，上来就dfs，然后在终止条件的地方进行判断，不合法再return。
理论上来讲，版本一的效率更高一些，因为避免了 没有意义的递归调用，在调用dfs之前，就做合法性判断。 但从写法来说，可能版本二 更利于理解一些。（不过其实都差不太多）
很多同学看了同一道题目，都是dfs，写法却不一样，有时候有终止条件，有时候连终止条件都没有，其实这就是根本原因，两种写法而已。
public class Number_of_Islands_Depth_First_Search {
public static int[][] dir ={{0,1},{1,0},{-1,0},{0,-1}};//二维数组，存储了深度优先搜索中可以探索的四个方向：右、下、左、上。
public static void dfs(boolean[][] visited,int x,int y ,int [][]grid)
{//递归方法，用于执行深度优先搜索。boolean[][] visited 参数是一个与grid同样大小的二维数组，用来标记某个单元格是否已经被访问过。int x 和 int y 分别是当前单元格的行和列索引。int[][] grid 是输入的二维数组，表示地图，其中1表示陆地，0表示水域。
for (int i = 0; i < 4; i++) {//对于当前单元格的每一个可能的相邻单元格（右、下、左、上），计算其坐标nextX和nextY。
int nextX=x+dir[i][0];
int nextY=y+dir[i][1];
if(nextY<0||nextX<0||nextX>= grid.length||nextY>=grid[0].length)
continue;//检查计算出的坐标是否在grid的边界内，并且该单元格是否未被访问过且值为1（陆地）。
if(!visited[nextX][nextY]&&grid[nextX][nextY]==1)
{//如果一个相邻单元格满足上述条件，将其标记为已访问，并递归调用dfs方法探索该单元格。
visited[nextX][nextY]=true;
dfs(visited,nextX,nextY,grid);
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//使用Scanner类从标准输入读取数据。
int m= sc.nextInt();//首先读取两个整数m和n，分别代表地图的行数和列数。
int n = sc.nextInt();
int[][] grid = new int[m][n];//创建一个大小为m x n的二维数组grid，用于存储地图数据。
for (int i = 0; i < m; i++) {//循环读取m x n个整数填充grid。
for (int j = 0; j < n; j++) {
grid[i][j]=sc.nextInt();
}
}
boolean[][]visited =new boolean[m][n];//创建一个大小为m x n的布尔二维数组visited，初始化为false，表示所有单元格都未被访问。
int ans = 0;//初始化一个整数ans用于存储岛屿的数量。
for (int i = 0; i < m; i++) {//遍历grid中的每个单元格，对于每个值为1且未被访问的单元格，执行以下操作：将ans加1，表示找到一个新岛屿。将该单元格标记为已访问。调用dfs方法从该单元格开始搜索整个岛屿。
for (int j = 0; j < n; j++) {
if(!visited[i][j]&&grid[i][j]==1)
{
ans++;
visited[i][j]=true;
dfs(visited,i,j,grid);
}
}
}
System.out.println(ans);
}
}
- 时间复杂度：O(4 * m * n)，其中m和n分别是地图的行数和列数。
- 空间复杂度：O(m * n)，主要由
visited数组和递归栈空间占用。
2.岛屿数量广搜
卡码网题目链接（ACM模式）(opens new window)
题目描述：
给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。
输入描述：
第一行包含两个整数 N, M，表示矩阵的行数和列数。
后续 N 行，每行包含 M 个数字，数字为 1 或者 0。
输出描述：
输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。
输入示例：
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1
输出示例：
3
提示信息
根据测试案例中所展示，岛屿数量共有 3 个，所以输出 3。
数据范围：
- 1 <= N, M <= 50
思路
注意题目中每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
也就是说斜角度链接是不算了， 例如示例二，是三个岛屿，如图：
这道题题目是 DFS，BFS，并查集，基础题目。
本题思路:遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。
再遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。
那么如果把节点陆地所能遍历到的陆地都标记上呢，就可以使用 DFS，BFS或者并查集。
广度优先搜索
如果不熟悉广搜，建议先看 广搜理论基础。
不少同学用广搜做这道题目的时候，超时了。 这里有一个广搜中很重要的细节：
根本原因是只要 加入队列就代表 走过，就需要标记，而不是从队列拿出来的时候再去标记走过。
很多同学可能感觉这有区别吗？
如果从队列拿出节点，再去标记这个节点走过，就会发生下图所示的结果，会导致很多节点重复加入队列。
超时写法 （从队列中取出节点再标记，注意代码注释的地方）
public class Number_of_Islands_Breadth_First_Search {
static class pair {//static class pair 是一个内部类，用于存储坐标对。int first 和 int second 分别存储x和y坐标。构造函数 pair(int first, int second) 初始化坐标对。
int first;
int second;
pair(int first, int second) {
this.first = first;
this.second = second;
}
}
public static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};//二维数组，存储了广度优先搜索中可以探索的四个方向：右、下、左、上。
public static void bfs(int[][] grid, boolean[][] visited, int x, int y) {//方法，用于执行广度优先搜索。int[][] grid 是输入的二维数组，表示地图，其中1表示陆地，0表示水域。boolean[][] visited 参数是一个与grid同样大小的二维数组，用来标记某个单元格是否已经被访问过。int x 和 int y 分别是当前单元格的行和列索引。
Queue<pair> queue = new LinkedList<pair>();//创建一个队列queue，用于存储待访问的坐标对。
queue.add(new pair(x, y));//将起始坐标(x, y)添加到队列中，并标记为已访问。
visited[x][y] = true;
while (!queue.isEmpty()) {//当队列不为空时，执行以下操作：取出队列中的下一个坐标(curX, curY)。对于当前坐标的每一个可能的相邻单元格（右、下、左、上），计算其坐标nextX和nextY。如果计算出的坐标在grid的边界内，并且该单元格未被访问过且值为1（陆地），则将其添加到队列中，并标记为已访问。
int curX = queue.peek().first;
int curY = queue.poll().second;
for (int i = 0; i < 4; i++) {
int nextX = curX + dir[i][0];
int nextY = curY + dir[i][1];
if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) {
continue;
}
if (!visited[nextX][nextY] && grid[nextX][nextY] == 1) {
queue.add(new pair(nextX, nextY));
visited[nextX][nextY] = true;
}
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//使用Scanner类从标准输入读取数据。
int m = sc.nextInt();//首先读取两个整数m和n，分别代表地图的行数和列数。
int n = sc.nextInt();
int[][] grid = new int[m][n];//创建一个大小为m x n的二维数组grid，用于存储地图数据。
boolean[][] visited = new boolean[m][n];//创建一个大小为m x n的布尔二维数组visited，初始化为false，表示所有单元格都未被访问。
int ans = 0;
for (int i = 0; i < m; i++) {//循环读取m x n个整数填充grid。
for (int j = 0; j < n; j++) {
grid[i][j] = sc.nextInt();
}
}
for (int i = 0; i < m; i++) {//初始化一个整数ans用于存储岛屿的数量。遍历grid中的每个单元格，对于每个值为1且未被访问的单元格，执行以下操作：将ans加1，表示找到一个新岛屿。调用bfs方法从该单元格开始搜索整个岛屿。
for (int j = 0; j < n; j++) {
if (!visited[i][j] && grid[i][j] == 1) {
ans++;
bfs(grid, visited, i, j);
}
}
}
System.out.println(ans);
}
}
- 时间复杂度：O(4 * m * n)，其中m和n分别是地图的行数和列数。
- 空间复杂度：O(m * n)，主要由
visited数组和队列空间占用。
3.岛屿的最大面积
卡码网题目链接（ACM模式）(opens new window)
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，计算岛屿的最大面积。岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。后续 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。
输出描述
输出一个整数，表示岛屿的最大面积。如果不存在岛屿，则输出 0。
输入示例
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1
输出示例
4
提示信息
样例输入中，岛屿的最大面积为 4。
数据范围：
- 1 <= M, N <= 50。
思路
注意题目中每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
也就是说斜角度链接是不算了， 例如示例二，是三个岛屿，如图：
这道题目也是 dfs bfs基础类题目，就是搜索每个岛屿上“1”的数量，然后取一个最大的。
本题思路上比较简单，难点其实都是 dfs 和 bfs的理论基础，关于理论基础我在这里都有详细讲解 ：
- DFS理论基础(opens new window)
- BFS理论基础(opens new window)
DFS
很多同学写dfs其实也是凭感觉来的，有的时候dfs函数中写终止条件才能过，有的时候 dfs函数不写终止添加也能过！
这里其实涉及到dfs的两种写法。
写法一，dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地。
写法二，dfs处理当前节点，即在主函数遇到岛屿就计数为0，dfs处理接下来的全部陆地
两种写法，版本一，在主函数遇到陆地就计数为1，接下来的相邻陆地都在dfs中计算。
版本二 在主函数遇到陆地 计数为0，也就是不计数，陆地数量都去dfs里做计算。
这也是为什么大家看了很多 dfs的写法 ，发现写法怎么都不一样呢？ 其实这就是根本原因。
BFS
关于广度优先搜索，如果大家还不了解的话，看这里：广度优先搜索精讲
public class Maximum_Area_of_an_Island {
static class Pair {//static class Pair 是一个辅助类，用于存储坐标对。int x 和 int y 分别存储横坐标和纵坐标。构造函数 Pair(int x, int y) 用于创建一个新的坐标对实例。
int x;
int y;
Pair(int x, int y) {
this.x = x;
this.y = y;
}
}
public static int[][] directions = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}}; // 定义了四个方向的移动，分别对应右、下、左、上。
public static void dfs(int[][] grid, boolean[][] visited, int x, int y, int[] area) {//输入的二维数组，表示地图，其中1表示陆地，0表示水域。boolean[][] visited 是一个与grid同样大小的布尔数组，用来标记某个单元格是否已经被访问过。int x 和 int y 是当前单元格的坐标。int[] area 是一个整数数组，用于计算当前岛屿的面积。
if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || visited[x][y] || grid[x][y] == 0) {
return;//检查当前坐标是否越界、是否已被访问或是否是水域。如果是，则返回。
}
visited[x][y] = true;//如果当前坐标是陆地（grid[x][y] == 1），则将其标记为已访问，并增加岛屿面积。
area[0]++;//然后，方法递归地对当前坐标的所有四个方向进行搜索，以找到整个岛屿。
for (int[] direction : directions) {
dfs(grid, visited, x + direction[0], y + direction[1], area);
}
}
public static int maxAreaOfIsland(int[][] grid) {
if (grid == null || grid.length == 0) {//检查输入的网格是否为空。
return 0;
}//创建一个布尔数组 visited 来跟踪访问过的单元格。
boolean[][] visited = new boolean[grid.length][grid[0].length];
int maxArea = 0;//初始化 maxArea 变量为0，用于存储最大岛屿面积。
for (int i = 0; i < grid.length; i++) {//遍历网格中的每个单元格，如果发现未访问的陆地（grid[i][j] == 1），则调用 dfs 方法计算该岛屿的面积，并更新 maxArea。
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 1 && !visited[i][j]) {
int[] area = new int[1]; // 用于计算当前岛屿的面积
dfs(grid, visited, i, j, area);
maxArea = Math.max(maxArea, area[0]);
}
}
}
return maxArea;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);//使用 Scanner 类从标准输入读取数据。
System.out.println("Enter the number of rows and columns:");
int m = scanner.nextInt();//首先读取两个整数 m 和 n，分别代表地图的行数和列数。
int n = scanner.nextInt();
int[][] grid = new int[m][n];//创建一个大小为 m x n 的二维数组 grid，用于存储地图数据。
System.out.println("Enter the grid values:");
for (int i = 0; i < m; i++) {//循环读取 m x n 个整数填充 grid。
for (int j = 0; j < n; j++) {//调用 maxAreaOfIsland 方法计算最大岛屿面积，并输出结果。
grid[i][j] = scanner.nextInt();
}
}
int maxArea = maxAreaOfIsland(grid);
System.out.println("Maximum area of an island is: " + maxArea);
}
}
- 时间复杂度：O(m * n)，其中m和n分别是地图的行数和列数。
- 空间复杂度：O(m * n)，主要由
visited数组和递归栈空间（或非递归DFS中的队列或栈）占用。
