[每日一题] leetcode 695. 岛屿的最大面积

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第9天，点击查看活动详情

695. 岛屿的最大面积

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例 1：

输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。

示例 2：

输入： grid = [[0,0,0,0,0,0,0,0]]
输出： 0

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 50
• grid[i][j] 为 0 或 1

思路

如何去扩展一个岛屿的周围的面积？

我们可以发现，每次扩展到一个新地方时，面临的问题和原问题一样

如何拓展一个区块上下左右的东西

那么这个就很明显了

我们可以去dfs染色方块

我们开一个数组，来标识是否走过

然后我们去dfs进去，依次染色，统计最大区块面积

就像这样：

0 => dfs(x - 1, y, n, m, vis, grid, cnt),
1 => dfs(x + 1, y, n, m, vis, grid, cnt),
2 => dfs(x, y + 1, n, m, vis, grid, cnt),
3 => dfs(x, y - 1, n, m, vis, grid, cnt),
_ => break,

这是一道dfs的经典问题了

代码

use std::cmp::max;
impl Solution {
    pub fn max_area_of_island(grid: Vec<Vec<i32>>) -> i32 {
        if grid.len() == 0 {
            return 0;
        }
        let mut ans = 0;
        let mut vis: Vec<Vec<i32>> = Vec::new();
        let n = grid.len();
        let m = grid[0].len();
        for i in 0..n {
            let mut ve: Vec<i32> = Vec::new();
            ve.resize(m, 0);
            vis.push(ve);
        }

        for i in 0..n {
            for j in 0..m {
                if vis[i][j] == 1 || grid[i][j] == 0 {
                    continue;
                }
                let mut cnt: i32 = 0;
                fn dfs(
                    x: i32, y: i32,
                    n: i32, m: i32,
                    vis: &mut Vec<Vec<i32>>,
                    grid: &Vec<Vec<i32>>,
                    cnt: &mut i32,
                ) {
                    if x < 0 || y < 0
                        || x >= n || y >= m
                        || vis[x as usize][y as usize] == 1
                        || grid[x as usize][y as usize] == 0
                    {
                        return;
                    }
                    vis[x as usize][y as usize] = 1;
                    *cnt += 1;
                    for i in 0..4 {
                        match i {
                            0 => dfs(x - 1, y, n, m, vis, grid, cnt),
                            1 => dfs(x + 1, y, n, m, vis, grid, cnt),
                            2 => dfs(x, y + 1, n, m, vis, grid, cnt),
                            3 => dfs(x, y - 1, n, m, vis, grid, cnt),
                            _ => break,
                        }
                    }
                }
                dfs(
                    i as i32, j as i32, n as i32, m as i32, &mut vis, &grid, &mut cnt,
                );
                ans = max(ans, cnt);
            }
        }
        return ans;
    }
}