代码随想录Day65

99.岛屿数量

题目：99. 岛屿数量 (kamacoder.com)

思路：先把矩阵信息存起来，再遍历数组，问题是这个岛屿的判定条件，要求四周都是水，才能称之为岛屿，而且陆地与陆地之间会连在一起，把遍历过的1变成2，这样只要你遍历到1周围有2，就说明两者是连在一起的，只有四周都是0，才加1，或者是遇到1且周围没有2才加1

尝试（写不出来）

import java.util.*

Class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.In);
        int n = scan.nextInt;
        int m = scan.nextInt;
        int[][] matrix = new int[n][m];
        for(int i = 0; i<n; i++){
            for(int j =0; j<m; j++){
                matrix[i][j] = scan.nextInt;
            }
        }
        for(int i = 0; i<n; i++){
            for(int j =0; j<m; j++){
                if(matrix[i][j]==1)
            }
        }
    }
    public static boolean findAround(int i, int j){
        if(matrix[i-1][j]&&matrix[i][j-1])
    }
}

深度优先搜索

import java.util.Scanner;

public class Main {
    private static int[][] grid;
    private static boolean[][] visited;
    private static int n, m;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        grid = new int[n][m];
        visited = new boolean[n][m];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }
        
        int maxArea = 0;
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    int area = dfs(i, j);
                    maxArea = Math.max(maxArea, area);
                }
            }
        }
        
        System.out.println(maxArea);
    }
    
    private static int dfs(int i, int j) {
        if (i < 0 || i >= n || j < 0 || j >= m || grid[i][j] == 0 || visited[i][j]) {
            return 0;
        }
        
        visited[i][j] = true;
        int area = 1;  // 当前格子的面积为1
        
        // 上
        area += dfs(i - 1, j);
        // 下
        area += dfs(i + 1, j);
        // 左
        area += dfs(i, j - 1);
        // 右
        area += dfs(i, j + 1);
        
        return area;
    }
}

广度优先搜索

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
    private static int[][] grid;
    private static boolean[][] visited;
    private static int n, m;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        grid = new int[n][m];
        visited = new boolean[n][m];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }
        
        int islandCount = 0;
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    bfs(i, j);
                    islandCount++;
                }
            }
        }
        
        System.out.println(islandCount);
    }
    
    private static void bfs(int i, int j) {
        int[] directions = {-1, 0, 1, 0, -1};  // 用于移动的方向：上、右、下、左
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{i, j});
        visited[i][j] = true;
        
        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int curRow = current[0];
            int curCol = current[1];
            
            for (int k = 0; k < 4; k++) {
                int newRow = curRow + directions[k];
                int newCol = curCol + directions[k + 1];
                
                if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < m &&
                    grid[newRow][newCol] == 1 && !visited[newRow][newCol]) {
                    queue.offer(new int[]{newRow, newCol});
                    visited[newRow][newCol] = true;
                }
            }
        }
    }
}

小结

遇到一个没有遍历过的节点陆地，计数器就加一，然后把该节点陆地所能遍历到的陆地都标记上。在遇到标记过的陆地节点和海洋节点的时候直接跳过。 这样计数器就是最终岛屿的数量。

100.岛屿的最大面积

题目：100. 岛屿的最大面积 (kamacoder.com)

思路：遍历岛屿时，要把岛屿面积算上，先定义个maxResult，每次遍历之后替换，想不到

深度优先搜索

import java.util.Scanner;

public class Main {
    private static int[][] grid;
    private static boolean[][] visited;
    private static int n, m;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        grid = new int[n][m];
        visited = new boolean[n][m];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }
        
        int maxArea = 0;
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    int area = dfs(i, j);
                    maxArea = Math.max(maxArea, area);
                }
            }
        }
        
        System.out.println(maxArea);
    }
    
    private static int dfs(int i, int j) {
        if (i < 0 || i >= n || j < 0 || j >= m || grid[i][j] == 0 || visited[i][j]) {
            return 0;
        }
        
        visited[i][j] = true;
        int area = 1;  // 当前格子的面积为1
        
        // 上
        area += dfs(i - 1, j);
        // 下
        area += dfs(i + 1, j);
        // 左
        area += dfs(i, j - 1);
        // 右
        area += dfs(i, j + 1);
        
        return area;
    }
}

小结