剑指Offer 105 岛屿的最大面积

题目描述：

给定一个由 0 和 1 组成的非空二维数组 grid ，用来表示海洋岛屿地图。

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

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

Level	AC rate
Medium	70.4%

---

题目解析：

第一个我们想到的就是暴力算法，遍历每一个点，如果该点为1，使用递归去发散寻找该点所在的岛屿，并将整个岛屿的点赋值为2，防止二次计算，然后将面积记录下来，通过比较可以得到该海域最大的岛屿面积为多少，代码如下：

// bf
class Solution {
    int area;
    public int maxAreaOfIsland(int[][] grid) {
        int ans = 0;
        area = 0;
        for(int i = 0 ; i<grid.length ; i++){
            for(int j = 0 ; j<grid[0].length ; j++){
                if(grid[i][j]==1){
                    infect(grid,i,j);
                    ans = Math.max(ans,area);
                    area = 0;
                }
            }
        }
        return ans;
    }
    
    void infect(int[][] grid , int x , int y){
        if(x<0||x>=grid.length||y<0||y>=grid[0].length||grid[x][y]!=1)return;
        grid[x][y] = 2;
        area++;
        infect(grid,x-1,y);
        infect(grid,x+1,y);
        infect(grid,x,y-1);
        infect(grid,x,y+1);
    }
}

执行用时：1 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：41.5 MB, 在所有 Java 提交中击败了58.00%的用户

然后我们想到通过并查集来进行并行运算，首先我们将整片海域从中间一分为2，按照第一题的原则依次计算左边海域和右边海域，注意这里我们使用到了一个help矩阵，来帮助我们进行统计判断，原理是这样，一开始，我们矩阵里放的值都为其下标，表明自己的父结点初始化为自己，然后通过我们的岛屿寻找过程，将每个点的值改为这片岛屿的寻找点，然后，我们沿着划分线做合并，如果划分先左右的值都为1，说明他两应该是连起来的，这个时候我们，将右方的父节点的父节点赋值为左方值的父节点，这样就相当于将两个集合合并了，代码如下：

// 并行算法
class Solution {
    int[] help;
    int m;
    int n;
    HashMap<Integer,Integer> map;
    public int maxAreaOfIsland(int[][] grid) {
        n = grid.length;
        m = grid[0].length;
        boolean decide = getv(grid);
        int ans = 0;
        if(m<2||n<2){
            int med = 0;
            for(int i = 0 ; i<n ; i++){
                for(int j = 0 ; j<m ; j++){
                    if(grid[i][j]==1)med++;
                    else{
                        ans = Math.max(ans,med);
                        med = 0;
                    }
                }
            }
            ans = Math.max(ans,med);
            return ans;
        }
        help = new int[m*n];
        map =  new HashMap<Integer,Integer>();
        for(int i = 0 ; i<m*n ; i++){
            help[i] = i;
        }
        for(int i = 0 ; i<n ; i++){
            for(int j = 0 ; j<m/2 ; j++){
                if(grid[i][j]==1)infect1(grid,i,j,i,j);
            }
        }
        for(int i = 0 ; i<n ; i++){
            for(int j = m/2 ; j<m ; j++){
                if(grid[i][j]==1)infect2(grid,i,j,i,j);
            }
        }
        // System.out.println(Arrays.toString(help));
        for(int i = 0 ; i<n ; i++){
            if(grid[i][m/2-1]==2&&grid[i][m/2]==2){
                if(!issameset(n*(m/2-1)+i,n*(m/2)+i)){
                    union(n*(m/2-1)+i,n*(m/2)+i);
                }
            }
        }
        adjust();
        for(int key:map.keySet()){
            ans = Math.max(ans,map.get(key));
        }
        return !decide?0:ans;
    }

    boolean issameset(int i , int j){
        int idx1 = find(i);
        int idx2 = find(j);
        if(idx1==idx2)return true;
        return false;
    }   

    void union(int i , int j){
        help[find(j)] = i;
    } 

    int find(int pos){
        Stack<Integer> stk = new Stack<Integer>();
        while(help[pos]!=pos){
            stk.add(pos);
            pos = help[pos];
        }
        while(!stk.isEmpty()){
            help[stk.pop()]=pos;
        }
        return pos;
    }

    void adjust(){
        for(int i = 0 ; i<m*n ; i++){
            int idx = find(i);
            help[i] =  idx;
            map.put(idx,map.getOrDefault(idx,0)+1);
        }
    }

    void infect1(int[][] grid , int x , int y , int headx , int heady){
        if(x<0||x>=n||y<0||y>=m/2||grid[x][y]!=1)return;
        grid[x][y] = 2;
        help[n*y+x] = n*heady+headx;
        infect1(grid,x-1,y,headx,heady);
        infect1(grid,x+1,y,headx,heady);
        infect1(grid,x,y-1,headx,heady);
        infect1(grid,x,y+1,headx,heady);
    }
    void infect2(int[][] grid , int x , int y , int headx , int heady){
        if(x<0||x>=n||y<m/2||y>=m||grid[x][y]!=1)return;
        grid[x][y] = 2;
        help[n*y+x] = n*heady+headx;
        infect2(grid,x-1,y,headx,heady);
        infect2(grid,x+1,y,headx,heady);
        infect2(grid,x,y-1,headx,heady);
        infect2(grid,x,y+1,headx,heady);
    }

    boolean getv(int[][] grid){
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j<m ; j++){
                if(grid[i][j]==1)return true;
            }
        }
        return false;
    }
}

执行用时：11 ms, 在所有 Java 提交中击败了5.24%的用户

内存消耗：41.6 MB, 在所有 Java 提交中击败了54.04%的用户

第一次写并查集，可能有些繁琐，但原理和思想确实都是并查集的，因为这里做的并不是两个GPU的并行计算，所以在运算速度上没有优化，反而因为繁琐的代码而慢了很多。