LeetCode827.最大人工岛

快乐早睡

于 2024-05-06 22:59:38 发布

阅读量695

点赞数 8

分类专栏： LeetCode 文章标签： C++ 深度优先图 leetcode 算法

本文链接：https://blog.csdn.net/weixin_40909461/article/details/138505294

版权

LeetCode 专栏收录该内容

132 篇文章 0 订阅

订阅专栏

本文介绍了如何使用深度优先搜索（DFS）解决LeetCode题目827，即在给定的二进制矩阵中找到通过改变一个0变为1可以达到的最大岛屿面积。通过两次遍历，第一次计算初始岛屿面积，第二次遍历找出0变为1后的可能增益，返回最大面积。

摘要由CSDN通过智能技术生成

在这里插入图片描述

LeetCode827.最大人工岛

题目：

给你一个大小为 n x n 二进制矩阵 grid 。最多只能将一格 0 变成 1 。
返回执行此操作后，grid 中最大的岛屿面积是多少？
岛屿由一组上、下、左、右四个方向相连的 1 形成。

示例：

输入： $g r i d = [[1, 0], [0, 1]]$
输出： $3$
解释： 将一格0变成1，最终连通两个小岛得到面积为 3 的岛屿。

解题思路：(DFS)
定义哈希表gridNum以及编号mark，gridNum存储每个岛屿的面积，每个不同的岛屿用不同的编号mark存储。
首先遍历一遍grid，得出每个岛屿的面积，然后用gridNum存储起来。然后再遍历一遍grid，遍历0出现的方格，并统计将该方格变成1之后，与相邻岛屿面积相加的值，遍历完所有的0之后，选出一个最大值返回即可。

C++版整体代码：

class Solution {
public:
	int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    int cnt;
    void dfs(vector<vector<int>>& grid, vector<vector<bool>>& visited, int x, int y, int mark){
        if(visited[x][y] || grid[x][y] == 0) return;
        visited[x][y] = true;
        grid[x][y] = mark;
        cnt++;
        for(int i = 0; i < 4; i++){
            int nextx = x + dx[i], nexty = y + dy[i];
            if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
            dfs(grid, visited, nextx, nexty, mark);
        }
    }
    int largestIsland(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        int mark = 2;
        vector<vector<bool>> visited = vector<vector<bool>>(n, vector<bool>(m, false));
        unordered_map<int, int> gridNum;
        bool isAllGrid = true;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j] == 0) isAllGrid = false;
                if(!visited[i][j] && grid[i][j] == 1){
                    cnt = 0;
                    dfs(grid, visited, i, j, mark);
                    gridNum[mark] = cnt;
                    mark++;
                }
            }
        }
        if(isAllGrid) return n * m;
        
        int res = 0;
        unordered_set<int> visitedGrid;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                int cnt = 1;
                visitedGrid.clear();
                if(grid[i][j] == 0){
                    for(int k = 0; k < 4; k++){
                        int nextx = i + dx[k], nexty = j + dy[k];
                        if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
                        if(visitedGrid.count(grid[nextx][nexty])) continue;
                        cnt += gridNum[grid[nextx][nexty]];
                        visitedGrid.insert(grid[nextx][nexty]);
                    }
                }
                res = max(res, cnt);
            }
        }
        return res;
    }
};