200. 岛屿数量-每日一题

一、题目

  给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

  岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

  此外，你可以假设该网格的四条边均被水包围。

点击查看原题
难度级别： 中等

二、思路

1）DFS

  使用visited记录进行深度搜索过的空格，不会重复计数岛屿（这里可以使用原本的数组空间进行优化，这里本着不想更改源数据的想法进行编码），每进行一次dfs，岛屿数量自增一

2）并查集

  并查集可以将连在一起的格子都指向一个根节点，将二维数组一维化，就可以使用并查集进行解题

三、代码

1）DFS

class Solution {
    private boolean[][] visited;
    private int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    public int numIslands(char[][] grid) {
        visited = new boolean[grid.length][grid[0].length];
        int ans = 0;

        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (visited[i][j] == false && grid[i][j] == '1') {
                    dfs(grid, i, j);
                    ans++;
                }
            }
        }
        return ans;
    }
    public void dfs(char[][] grid, int row, int col) {
        if (grid[row][col] == '0') {
            return ;
        }
        visited[row][col] = true;
        for (int[] dir : dirs) {
            int newRow = row + dir[0];
            int newCol = col + dir[1];
            if (newRow >= 0 && newRow < grid.length 
                    && newCol >= 0 && newCol < grid[0].length 
                    && visited[newRow][newCol] == false) {
                dfs(grid, newRow, newCol);
            }
        }
    }
}

  时间复杂度为O(m*n)，空间复杂度为O(m*n)

2）并查集

class Solution {
    public int numIslands(char[][] grid) {
        int oneCnt = 0;
        UnionFind uf = new UnionFind(grid.length * grid[0].length);
        int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == '1') {
                    oneCnt++;
                    for (int[] dir : dirs) {
                        int newI = i + dir[0];
                        int newJ = j + dir[1];
                        if (newI >= 0 && newI < grid.length
                                && newJ >= 0 && newJ < grid[0].length
                                && grid[newI][newJ] == '1') {
                            uf.union(i*grid[0].length + j, newI *grid[0].length + newJ);
                        }
                    }
                }
            }
        }
        return oneCnt - uf.getMeregeCnt();
    }
}
class UnionFind {
    private int[] ranks;
    private int[] parents;
    private int meregeCnt = 0;
    public UnionFind(int n) {
        ranks = new int[n+1];
        parents = new int[n+1];
        for (int i = 1; i < n; i++) {
            parents[i] = i;
        }
    }
    public int findParent(int x) {
        if (parents[x] != x) {
            parents[x] = findParent(parents[x]);
        }
        return parents[x];
    }
    public void union(int x, int y) {
        int xP = findParent(x);
        int yP = findParent(y);
        if (xP == yP) {
            return ;
        }
        if (ranks[xP] > ranks[yP]) {
            parents[yP] = xP;
        } else if (ranks[xP] < ranks[yP]) {
            parents[xP] = yP;
        } else {
            parents[yP] = xP;
            ranks[xP]++;
        }
        meregeCnt++;
    }
    public int getMeregeCnt() {
        return meregeCnt;
    }
}

  a是四次union的时间，时间复杂度为O(m*n*a)，空间复杂度为O(m*n)