695. 岛屿的最大面积并查集 dfs

最新推荐文章于 2025-06-05 21:10:12 发布

原创最新推荐文章于 2025-06-05 21:10:12 发布 · 321 阅读

0 ·

CC 4.0 BY-SA版权

程序片段专栏收录该内容

107 篇文章

订阅专栏

本文详细解析了在二维数组中寻找最大岛屿面积的算法。通过并查集和深度优先搜索两种方法，阐述了如何有效计算由1代表的土地组成的最大岛屿面积，特别关注岛屿只能由水平或垂直的1构成的条件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个包含了一些 0 和 1的非空二维数组 grid , 一个岛屿是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)

示例 1:

[[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:

[[0,0,0,0,0,0,0,0]]

对于上面这个给定的矩阵, 返回 0。

注意: 给定的矩阵grid 的长度和宽度都不超过 50。

思路并查集

class Solution {
    private:
        int num;
        int* father = new int[3000];

        void init(int x) {
            num = x;
            for(int i = 1; i <= num; i++)
                father[i] = i;
        }

        int find(int x) {
            if(father[x] != x)
                father[x] = find(father[x]);
            return father[x];
        }

        void merge(int x, int y) {
            int a = find(x);
            int b = find(y);
            if(a != b)
                father[b] = a;
        }

        int getSubsetNum() {
            int res = 0;
            for(int i = 1; i <= num; i++)
                if(father[i] == i)
                    res++;
            return res;
        }

        int getMaxNum()
        {
            vector<int> vt(3000,0);
            for(int i = 1; i <= num; i++)
                if(father[i]>0)
                {
                	//cout<<father[i]<<endl;
                    //cout<<i<<" "<<find(i)<<endl;
                    vt[find(i)]++;
                }
            return *max_element(vt.begin(),vt.end());
        }

    public:

        int xx[4]= {1,-1,0,0};
        int yy[4]= {0,0,1,-1};
        int n,m;
        int icount=0;


        int maxAreaOfIsland(vector<vector<int>>& grid) {
            n=grid.size();
            if(n==0) return 0;
            m=grid[0].size();

            int inum=0;
            init(m*n);
            for(int i=0; i<n; i++)
                for(int j=0; j<m; j++) {
                    if(grid[i][j]==1) inum++;
                    else father[i*m+j+1]=-1;
                }

            for(int i=0; i<n; i++)
                for(int j=0; j<m; j++)
                {
                    if(grid[i][j]==0) continue;
                    for(int k=0; k<4; k++) {
                        int nx=i+xx[k];
                        int ny=j+yy[k];
                        if(nx<0||nx>=n||ny<0||ny>=m) continue;
                        else 
                        {
                            if(grid[nx][ny]==1)
                            {
                                merge(i*m+j+1,nx*m+ny+1);
                            }
                        }
                    }
                }

            return getMaxNum();
        }
};

dfs

class Solution {
	public:
 
		int xx[4]= {1,-1,0,0};
		int yy[4]= {0,0,1,-1};
		int n,m;
		int icount=0,imax=0;
		void  dfs(int x,int y,vector< vector<bool> > &vist) {
			vist[x][y]=true;
			icount++;
			imax=max(icount,imax);
			for(int k=0; k<4; k++) {
				int nx=x+xx[k];
				int ny=y+yy[k];
				if(nx<0||nx>=n||ny<0||ny>=m)
					continue;
				if(!vist[nx][ny])
				{
					dfs(nx,ny,vist);
				}
					
			}
		}
		int maxAreaOfIsland(vector<vector<int>>& grid) {
			n=grid.size();
			if(n==0) return 0;
			m=grid[0].size();
			vector<bool> t(m,0);
			vector< vector<bool> > vist(n,t);
			for(int i=0; i<n; i++)
				for(int j=0; j<m; j++) {
					if(grid[i][j]==0) vist[i][j]=true;
				}
				
			for(int i=0; i<n; i++)
				for(int j=0; j<m; j++) {
					if(!vist[i][j]) {
						icount=0;
						dfs(i,j,vist);
					}
				}
 
			cout<<imax<<endl;
			return imax;
		}
};