FloodFill_最大岛屿面积计算或者岛屿个数计算

题目：

https://leetcode-cn.com/problems/max-area-of-island/

给定一个包含了一些 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。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-area-of-island
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

 

实现：

//==================================================================================================
//总的思路：1、获取所有岛屿个数（FloodFill）；2、得到面积最大的岛屿
//==================================================================================================

import java.util.Arrays;

public class Main {

    private static int[][] direction = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    private static boolean[][] visitFlag;
    private static int m, n;
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

    // 计算面积有多少个岛屿
    public int numOfIsland(int[][] grid) {
        m = grid.length;
        if (m < 1) return 0;
        n = grid[0].length;

        // 初始化标记所有点都没有访问
        visitFlag = new boolean[50][50];
        for (int i=0;i<50;i++) {
            Arrays.fill(visitFlag[i],false);
        }

        int count = 0;
        for (int k=0;k<m;k++) {
            for (int h=0;h<n;h++) {
                if(grid[k][h] == 1 && !visitFlag[k][h]) {
                    count++;
                    dfs(grid, k, h);
                }
            }
        }
        return count;
    }

    // 深度优先遍历
    private void dfs(int[][] grid, int k, int h) {
        visitFlag[k][h] = true;
        for(int i=0; i<4; i++) {
            int newX = k + direction[i][0];
            int newY = h + direction[i][1];
            if (inArea(newX,newY) && !visitFlag[newX][newY] && grid[newX][newY] == 1) {
                dfs(grid, newX, newY);
            }
        }
    }


    // 判断下标为x，y的元素是否还在区域里面
    public boolean inArea(int x, int y) {
        return x >= 0 && x < m && y>=0 && y < n;
    }
}

//========================================list标志，时间换空间==============================================================

import java.util.Vector;
class Solution {
    private static int[][] direction = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    private static Vector<Vector<Boolean>> visitFlag;
    private static int m, n;
    
    public int maxAreaOfIsland(int[][] grid) {
        m = grid.length;
        if (m < 1) return 0;
        n = grid[0].length;

        // 初始化标记所有点都没有访问
        visitFlag = new Vector<>();
        for (int i=0;i<m;i++) {
            Vector<Boolean> column = new Vector<>();
            for (int j=0;j<n;j++) column.add(false);
            visitFlag.add(column);
        }

        int count = 0;
        int result = 0;
        for (int k=0;k<m;k++) {
            for (int h=0;h<n;h++) {
                Vector<Boolean> toChangeFlagVector = visitFlag.get(k);
                boolean toChangeFlag = toChangeFlagVector.get(h);
                if(grid[k][h] == 1 && !toChangeFlag) {
                    count++;
                    int temp = dfs(grid, k, h);
                    result = temp > result ? temp : result;
                }
            }
        }
        return result;
    }

    private int dfs(int[][] grid, int k, int h) {
        int result = 1;
        visitFlag.get(k).set(h,true);
        for(int i=0; i<4; i++) {
            int newX = k + direction[i][0];
            int newY = h + direction[i][1];
            if (inArea(newX,newY) && !visitFlag.get(newX).get(newY) && grid[newX][newY] == 1) {
                result += dfs(grid, newX, newY);
            }
        }
        return result;
    }


    // 判断下标为x，y的元素是否还在区域里面
    public boolean inArea(int x, int y) {
        return x >= 0 && x < m && y>=0 && y < n;
    }


    
}

// =========================================二维数组标记，空间换时间============================

import java.util.Arrays;

public class Main {

    private static int[][] direction = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    private static boolean[][] visitFlag;
    private static int m, n;
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

    // 计算面积最大的岛屿
    public int maxAreaOfIsland(int[][] grid) {
        m = grid.length;
        if (m < 1) return 0;
        n = grid[0].length;

        // 初始化标记所有点都没有访问
        visitFlag = new boolean[50][50];
        for (int i=0;i<50;i++) {
            Arrays.fill(visitFlag[i],false);
        }

        int count = 0;
        int result = 0;
        for (int k=0;k<m;k++) {
            for (int h=0;h<n;h++) {
                if(grid[k][h] == 1 && !visitFlag[k][h]) {
                    count++;
                    int temp = dfs(grid, k, h);
                    result = temp > result ? temp : result;
                }
            }
        }
        return result;
    }

    // 深度优先遍历
    private int dfs(int[][] grid, int k, int h) {
        int result = 1;
        visitFlag[k][h] = true;
        for(int i=0; i<4; i++) {
            int newX = k + direction[i][0];
            int newY = h + direction[i][1];
            if (inArea(newX,newY) && !visitFlag[newX][newY] && grid[newX][newY] == 1) {
                result += dfs(grid, newX, newY);
            }
        }
        return result;
    }


    // 判断下标为x，y的元素是否还在区域里面
    public boolean inArea(int x, int y) {
        return x >= 0 && x < m && y>=0 && y < n;
    }
}