leetcode-827:最大人工岛

简介: leetcode-827:最大人工岛

题目

题目连接

给你一个大小为 n x n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。

返回执行此操作后,grid 中最大的岛屿面积是多少?

岛屿 由一组上、下、左、右四个方向相连的 1 形成。

示例 1:

输入: grid = [[1, 0], [0, 1]]
输出: 3
解释: 将一格0变成1,最终连通两个小岛得到面积为 3 的岛屿。

示例 2:

输入: grid = [[1, 1], [1, 0]]
输出: 4
解释: 将一格0变成1,岛屿的面积扩大为 4。

示例 3:

输入: grid = [[1, 1], [1, 1]]
输出: 4
解释: 没有0可以让我们变成1,面积依然为 4。

解题

方法一:dfs+map+枚举变化点

通过map记录每个岛屿对应的面积

通过不同值去标记不同的岛屿。

然后遍历矩阵,尝试让0变成1,然后查看最大面积

class Solution {
public:
    vector<vector<int>> dirs={{-1,0},{1,0},{0,-1},{0,1}};
    void dfs(unordered_map<int,int>& mp,vector<vector<int>>& grid,int id,int x,int y,int& area){
        grid[x][y]=id;
        area++;
        for(vector<int>& dir:dirs){
            int nx=x+dir[0];
            int ny=y+dir[1];
            if(nx<0||nx>=grid.size()||ny<0||ny>=grid.size()||grid[nx][ny]!=1) continue;
            dfs(mp,grid,id,nx,ny,area);
        }
    }
    int largestIsland(vector<vector<int>>& grid) {
        int n=grid.size();
        int id=-1;
        unordered_map<int,int> mp;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]!=1) continue;
                int area=0;
                dfs(mp,grid,id,i,j,area);
                mp[id]=area;
                id--;
            }
        }
        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==0){
                    unordered_set<int> set;
                    int cur=1;
                    for(vector<int>& dir:dirs){
                        int nx=i+dir[0];
                        int ny=j+dir[1];
                        if(nx<0||nx>=n||ny<0||ny>=n||grid[nx][ny]==0) continue;
                        if(!set.count(grid[nx][ny])){
                            cur+=mp[grid[nx][ny]];
                            set.insert(grid[nx][ny]);
                        }
                    }
                    res=max(res,cur);
                }
            }
        }
        return res==0?n*n:res;//全1的情况下res不会进行更新。 只要有0, res至少为1
    }
};

方法二:并查集+枚举

查并集,可以查看每个集合中元素的数量

第一次遍历,将相邻的陆地加入到一个集合中

第二次遍历,如何相邻岛屿,那么就将它们岛屿的面积(集合的大小)加起来,注意去重。

class UnionFind{
public:
    vector<int> parent;
    vector<int> size;
    UnionFind(int n){
        parent.resize(n*n);
        size.resize(n*n,1);
        iota(parent.begin(),parent.end(),0);
    }
    int find(int index){
        if(index==parent[index]) return index;
        return parent[index]=find(parent[index]);
    }
    void unite(int index1,int index2){
        int p1=find(index1),p2=find(index2);
        parent[p1]=p2;
        if(p1!=p2){//如果相等,会出现把size[p1]=size[p2]=0 都清空
            size[p2]+=size[p1];
            size[p1]=0;
        }
    }
    int getSize(int index){
        return size[find(index)];
    }
};
class Solution {
public:
    vector<vector<int>> dirs={{-1,0},{0,-1},{1,0},{0,1}};
    int largestIsland(vector<vector<int>>& grid) {
        int n=grid.size();
        UnionFind uf(n);
        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1){
                    for(int k=0;k<2;k++){
                        vector<int>& dir=dirs[k];
                        int nx=i+dir[0];
                        int ny=j+dir[1];
                        if(nx<0||nx>=n||ny<0||ny>=n||grid[nx][ny]==0) continue;
                        uf.unite(nx*n+ny,i*n+j);
                    }
                    res=max(res,uf.getSize(i*n+j));
                }
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==0){
                    int cur=1;
                    unordered_set<int> set;
                    for(vector<int>& dir:dirs){
                        int nx=i+dir[0];
                        int ny=j+dir[1];
                        if(nx<0||nx>=n||ny<0||ny>=n||grid[nx][ny]==0) continue;
                        int p=uf.find(nx*n+ny);
                        if(!set.count(p)){
                            cur+=uf.getSize(p);
                            set.insert(p);
                        }
                    }
                    res=max(cur,res);
                }
            }
        }
        return res;
    }
};
相关文章
|
6月前
leetcode-1518:换酒问题
leetcode-1518:换酒问题
33 0
|
6月前
|
消息中间件 Kubernetes NoSQL
LeetCode 1359、1360
LeetCode 1359、1360
|
Python
LeetCode 1904. 你完成的完整对局数
一款新的在线电子游戏在近期发布,在该电子游戏中,以 刻钟 为周期规划若干时长为 15 分钟 的游戏对局。这意味着,在 HH:00、HH:15、HH:30 和 HH:45 ,将会开始一个新的对局,其中 HH 用一个从 00 到 23 的整数表示。游戏中使用 24 小时制的时钟 ,所以一天中最早的时间是 00:00 ,最晚的时间是 23:59 。
104 0
|
存储 Python
LeetCode 66. Plus One
给定表示非负整数的非空数字数组,加上整数的1。 存储数字使得最高有效数字位于列表的开头,并且数组中的每个元素包含单个数字。 您可以假设整数不包含任何前导零,除了数字0本身。
92 0
LeetCode 66. Plus One
|
算法 Java
一和零(LeetCode 474)
一和零(LeetCode 474)
96 0
leetcode第34题
从左向右遍历,一旦出现等于 target 的值就结束,保存当前下标。如果从左到右没有找到 target,那么就直接返回 [ -1 , -1 ] 就可以了,因为从左到右没找到,那么从右到左也一定不会找到的。如果找到了,然后再从右到左遍历,一旦出现等于 target 的值就结束,保存当前下标。 时间复杂度是 O(n)并不满足题意,但可以了解下这个思路,从左到右,从右到左之前也遇到过。
leetcode第34题
|
存储
leetcode第57题
和上一道可以说是一个问题,只不过这个是给一个已经合并好的列表,然后给一个新的节点依据规则加入到合并好的列表。 解法一 对应 56 题的解法一,没看的话,可以先过去看一下。这个问题其实就是我们解法中的一个子问题没看的话,可以先过去看一下。这个问题其实就是我们解法中的一个子问题, 所以直接加过来就行了
leetcode第57题
leetcode第39题
对回溯法又有了更深的了解,一般的架构就是一个大的 for 循环,然后先 add,接着利用递归进行向前遍历,然后再 remove ,继续循环。而解法二的动态规划就是一定要找到递进的规则,开始的时候就想偏了,导致迟迟想不出来。
leetcode第39题
leetcode第36题
一个 9 * 9 的数独的棋盘。判断已经写入数字的棋盘是不是合法。需要满足下边三点, • 每一行的数字不能重复 • 每一列的数字不能重复 • 9 个 3 * 3 的小棋盘中的数字也不能重复。 只能是 1 - 9 中的数字,不需要考虑数独最后能不能填满
leetcode第36题
leetcode第38题
难在了题目是什么意思呢? 初始值第一行是 1。 第二行读第一行,1 个 1,去掉个字,所以第二行就是 11。 第三行读第二行,2 个 1,去掉个字,所以第三行就是 21。 第四行读第三行,1 个 2,1 个 1,去掉所有个字,所以第四行就是 1211。 第五行读第四行,1 个 1,1 个 2,2 个 1,去掉所有个字,所以第五航就是 111221。 第六行读第五行,3 个 1,2 个 2,1 个 1,去掉所以个字,所以第六行就是 312
leetcode第38题