LeetCode 200. Number of Islands

wenyq7

已于 2024-05-23 15:59:24 修改

阅读量195

点赞数

分类专栏： LeetCode 文章标签： leetcode 深度优先算法

于 2019-10-07 14:07:25 首次发布

本文链接：https://blog.csdn.net/qq_37333947/article/details/102301189

版权

LeetCode 专栏收录该内容

286 篇文章 1 订阅

订阅专栏

题目：

Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

Input:
11110
11010
11000
00000

Output: 1

Example 2:

Input:
11000
11000
00100
00011

Output: 3

这道题的题意大概是，给一个N*M的0-1矩阵，求相连的'1'的片数。一拿到题就愣住了，会往BFS、DFS方面想，但是一看到这还是二维的就退缩了……然后看完答案感觉豁然开朗，其实好像二维的也不是很难呢……

1. BFS

首先来讨论我比较熟悉的BFS的做法。整体的思路就是，我们对每一个标记为'1'的格子进行BFS搜索，queue里存放的是格子的坐标，将符合条件（没有越界且标记为'1'）的格子的上下左右push到queue中，并将这个已访问的格子标记为0，不让它重复出现。

要写起代码来的话，最外层的循环就是对整个grid的每个cell进行遍历，所以是一个N*M的双重for loop，如果当前的cell值为1，那么这是一块island的开始，需要result++，并将它标记为0，然后将row和col值push到queue中，进行常规的BFS操作，把它上下左右（需要用到if来判断是否超出格子范围）标记为1的格子都push进queue中并标记为0。但是这里不需要内层的for循环，具体原因还没完全想通。

代码的时间复杂度O(M*N)，因为有两重循环，里面的while循环似乎不占时间复杂度，这里还没想清楚。空间复杂度O(min(M, N))，最坏的情况下是所有的格子都是1，也就是queue的大小至少为M和N中较小的那个。

C++版：运行时间16 ms，59.66%，空间11.2 MB，33.71%：

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int rows = grid.size();
        if (rows == 0) {
            return 0;
        }
        int cols = grid[0].size();
        int result = 0;
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == '1') {
                    result++;
                    grid[i][j] = '0';
                    queue<pair<int, int>> q;
                    q.push({i, j});
                    while (q.size() != 0) {
                        int size = q.size();
                        //for (int k = 0; k < size; k++) {
                        pair<int, int> front = q.front();
                        q.pop();
                        int row = front.first;
                        int col = front.second;
                        if (row - 1 >= 0 && grid[row - 1][col] == '1') {
                            q.push({row - 1, col});
                            grid[row - 1][col] = '0';
                        }
                        if (row + 1 < rows && grid[row + 1][col] == '1') {
                            q.push({row + 1, col});
                            grid[row + 1][col] = '0';
                        }
                        if (col - 1 >= 0 && grid[row][col - 1] == '1') {
                            q.push({row, col - 1});
                            grid[row][col - 1] = '0';
                        }
                        if (col + 1 < cols && grid[row][col + 1] == '1') {
                            q.push({row, col + 1});
                            grid[row][col + 1] = '0';
                        }  
                        //}
                    }
                }
            }
        }
        return result;
    }
};

Java版：运行时间4ms，20.11%，空间41.9MB，46.98%：

（java里面没有pair真是太麻烦了，存queue的时候只能存id了然后再把它拆开成row和col，拆的时候注意是row * cols + col而不是* rows……）

class Solution {
    public int numIslands(char[][] grid) {
        int result = 0;
        if (grid == null || grid.length == 0) {
            return result;
        }
        int rows = grid.length;
        int cols = grid[0].length;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == '1') {
                    result++;
                    Queue<Integer> neighbors = new LinkedList<>();
                    neighbors.add(i * cols + j);
                    
                    while (!neighbors.isEmpty()) {
                        int id = neighbors.remove();
                        int r = id / cols;
                        int c = id % cols;
                        if (r - 1 >= 0 && grid[r - 1][c] == '1') {
                            grid[r - 1][c] = '0';
                            neighbors.add((r - 1) * cols + c);
                        }
                        if (r + 1 < rows && grid[r + 1][c] == '1') {
                            grid[r + 1][c] = '0';
                            neighbors.add((r + 1) * cols + c);
                        }
                        if (c - 1 >= 0 && grid[r][c - 1] == '1') {
                            grid[r][c - 1] = '0';
                            neighbors.add(r * cols + c - 1);
                        }
                        if (c + 1 < cols && grid[r][c + 1] == '1') {
                            grid[r][c + 1] = '0';
                            neighbors.add(r * cols + c + 1);
                        }
                    }
                }
            }
        }
        return result;
    }
}

2024.5.22 update Java

时隔三年半还是不会做……以为自己掌握了bfs但是感觉只了解个大体的框架但是没有深入理解和灵活使用。其实思路看之前写的就差不多了，主要就是这里的queue是在loop每一个格子里，用来存每一个格子的非0邻居们，也不需要用到queue.size()。写了个自定义Pair的版本

class Solution {
    public int numIslands(char[][] grid) {
        int result = 0;
        for (int r = 0; r < grid.length; r++) {
            for (int c = 0; c < grid[0].length; c++) {
                if (grid[r][c] == '1') {
                    result++;
                    Queue<Pair> neighbors = new ArrayDeque<>();
                    neighbors.add(new Pair(r, c));
                    while (!neighbors.isEmpty()) {
                        Pair curr = neighbors.remove();
                        int i = curr.getX();
                        int j = curr.getY();
                        if (i - 1 >= 0 && grid[i - 1][j] == '1') {
                            grid[i - 1][j] = '0';
                            neighbors.add(new Pair(i - 1, j));
                        }
                        if (i + 1 < grid.length && grid[i + 1][j] == '1') {
                            grid[i + 1][j] = '0';
                            neighbors.add(new Pair(i + 1, j));
                        }
                        if (j - 1 >= 0 && grid[i][j - 1] == '1') {
                            grid[i][j - 1] = '0';
                            neighbors.add(new Pair(i, j - 1));
                        }
                        if (j + 1 < grid[0].length && grid[i][j + 1] == '1') {
                            grid[i][j + 1] = '0';
                            neighbors.add(new Pair(i, j + 1));
                        }
                    }
                }

            }
        }
        return result;
    }

    private class Pair {
        private int x;
        private int y;

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int getX() {
            return this.x;
        }

        public int getY() {
            return this.y;
        }
    }
}

2. DFS

DFS的思路其实和BFS几乎是一样的，就是写代码的方式不太一样。DFS一般都可以写成一个独立的递归函数，在这道题二维的情况下，函数的参数应该是整个grid和一个格子的坐标（row、col）。每次DFS一个格子，都要将这个格子设置成0，并对存在且为1的上下左右格子递归调用DFS函数。在主函数中也和BFS类似，对于每个格子都进行遍历，如果为1，那么这是island的开始，然后调用DFS函数将连成一片的格子都标为0，进入后面格子的循环遍历。代码的时间复杂度O(M*N)，因为有两重循环。空间复杂度O(M*N)，最坏的情况下是所有的格子都是1，也就是DFS需要遍历整个grid，也就是M*N。

C++版：运行时间12ms，91.90%，空间10.9MB，64.04%。（看来这道题用DFS的性能比BFS好很多啊）：

class Solution {
public:
    void dfs(vector<vector<char>>& grid, int row, int col) {
        int rows = grid.size();
        int cols = grid[0].size();
        
        grid[row][col] = '0';
        if (row - 1 >= 0 && grid[row - 1][col] == '1') {
            dfs(grid, row - 1, col);
        }
        if (row + 1 < rows && grid[row + 1][col] == '1') {
            dfs(grid, row + 1, col);
        }
        if (col - 1 >= 0 && grid[row][col - 1] == '1') {
            dfs(grid, row, col - 1);
        }
        if (col + 1 < cols && grid[row][col + 1] == '1') {
            dfs(grid, row, col + 1);
        }
        
    }
    int numIslands(vector<vector<char>>& grid) {
        int rows = grid.size();
        if (rows == 0) {
            return 0;
        }
        int cols = grid[0].size();
        int result = 0;
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == '1') {
                    result++;
                    dfs(grid, i, j);
                }
            }
        }
        return result;
    }
};

Java版：运行时间1ms，99.99%，空间42.1MB，32.56%

class Solution {
    private void dfs(char[][] grid, int i, int j) {
        int rows = grid.length;
        int cols = grid[0].length;
        
        if (i < 0 || i == rows || j < 0 || j == cols || grid[i][j] == '0') {
            return;
        }
        
        grid[i][j] = '0';
        
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }
    
    public int numIslands(char[][] grid) {
        int result = 0;
        if (grid == null || grid.length == 0) {
            return result;
        }
        int rows = grid.length;
        int cols = grid[0].length;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == '1') {
                    result++;
                    dfs(grid, i, j);
                }
            }
        }
        return result;
    }
}

另外这道题还可以用union find做，刚听完Princeton Algorithm Part I第一节就是讲的union find于是终于能回来填坑了，之前遗留的从lc上摘抄的先不动好了。

Algorithm

Traverse the 2d grid map and union adjacent lands horizontally or vertically, at the end, return the number of connected components maintained in the UnionFind data structure.

For details regarding to Union Find, you can refer to this article.

Union Find可以用来解决连通图（？）的问题，大概就是给定一些点，判断两点之间是否连通。Union Find主要有两个操作，一个是union，就是把两个点连起来；另一个是find，就是判断两个点是不是connected（但是看lc上solution的find函数写的是找它的连通根的样子，我这里先按照Princeton课上的讲法来写）。

对于union find这个class，因为存的是一系列的点，于是我们需要用一个int数组来表示每一个点，叫做int[] id，在union操作过程中，如果要把两个点连接起来，就把它们设为一样的id即可，也就相当于找一个点来代表这一整个connected component。在find的时候，只需要判断两个点所在的connected component的代表点是不是一样即可。

首先第一种不那么好的算法叫做quick-find，也就是find的时候很快，可以O(1)，但是union的时候很慢，需要O(n)。这个算法的思想在于在union(a, b)的时候把所有id和a相同的全部改成b的id，于是find(a, b)的时候可以直接通过比较id[a]和id[b]是否相同来达到O(1)的效果。但是实际上，我们进行union的操作次数要比find多多了，所以union很慢就影响很大，于是就有改进版的，叫做quick-union。

quick-union顾名思义就是union快，但是其实也没有快到O(1)，大概也是O(n)，但是要比quick-find要好得多，而find在worst case情况下就变成了O(n)了。quick-union把这些点看作一个森林，每一个connected component作为一棵树，于是union的时候相当于就是合并两棵树，find的时候就是查树的根结点。于是我们发现，不管是union还是find，都需要知道树的根root是多少，所以就需要写一个helper function叫做root(i)，负责来查找一个节点对应的根。在最最普通的quick-union实现中，id代表的是这个节点的父节点而不是根，如果一个节点是根的话，它的id就等于它自己，所以root函数需要while循环到id[i] == i时停止并返回i。find就是简单地调用root函数看两个是否相等，union(a, b)需要将id[a]设为b的根，也就是root(b)。

这个方法其实还可以继续改进，比如当树很高的时候，这个找root操作的性能就可能会下降到需要N次操作。于是我们可以用weighted quick-union方法，也就是每次把size小的树挂到size大的树下，注意这里的size指的是树里含有节点的个数而不是树的高度。于是我们在union find class中还需要加一个数组，表示每个节点的size。在union的过程中需要特别注意，在赋值id和比较/修改size的时候，都应该直接修改根的而不是union的那两个节点的！然而在lc的solution中，它叫做用rank来union，我观察了一下它是刚开始把所有节点的rank都设为0，然后在union的两个根的rank一样的情况下，做为根的那个rank++，好像也不是不行，跟用size相比好像还更简单一点。（诶这个似乎有点像树高的样子？）

这个还可以继续优化，因为每次做root操作找根的时候，总是有那么几个节点被access了多次，于是我们可以直截了当地把这些节点都挂到根下面。比如下面这个图中就是先把9为根的子树挂到0上，然后挂6为根的子树，最后把3为根的子树挂上去。

这种方法实现起来就是要在root函数中加一行代码，在while中遍历的时候，每次都把当前节点的根改成当前节点的根的根，最后相当于就都挂到真正的根下面了。而lc的solution中这个root是递归方式写的，它把while改成了if，然后在if里面递归调用它自己，参数传它的父节点，好像还更好理解一些。

嗯讲完了union find的原理回到这道题，这道题需要求有多少个connected component，于是我们还要在union find class中新增一个count变量用来记录个数。在initialize的时候把这个count initialize成1的个数，然后每次union的时候把这个count--即可。

这个方法时空复杂度也都是O(M*N)。

Runtime: 5 ms, faster than 11.82% of Java online submissions for Number of Islands.

Memory Usage: 41.8 MB, less than 49.30% of Java online submissions for Number of Islands.

class Solution {
    class UnionFind {
        int[] id;
        int[] size;
        int count;
        
        public UnionFind(char[][] grid) {
            count = 0;
            int rows = grid.length;
            int cols = grid[0].length;
            id = new int[rows * cols];
            size = new int[rows * cols];
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < cols; j++) {
                    id[i * cols + j] = i * cols + j;
                    size[i * cols + j] = 0;
                    if (grid[i][j] == '1') {
                        count++;
                    }
                }
            }
        }
        
        public int root(int i) {
            while (id[i] != i) {
                id[i] = id[id[i]];  // path compression
                i = id[i];
            }
            return i;
        }
        
        public void union(int p, int q) {
            int rootp = root(p);
            int rootq = root(q);
            // if p and q are connected to the same cell
            if (rootp != rootq) {
                // put smaller tree under bigger tree
                // be aware that we should use rootp/rootq instead of p/q
                if (size[rootp] > size[rootq]) {
                    id[rootq] = rootp;
                    size[rootp] += size[rootq];
                } else {
                    id[rootp] = rootq;
                    size[rootq] += size[rootp];
                }
                count--;
            }
        }
        
        public int getCount() {
            return count;
        }
    }
    
  public int numIslands(char[][] grid) {
      if (grid == null || grid.length == 0) {
          return 0;
      }
      
      int rows = grid.length;
      int cols = grid[0].length;
      UnionFind uf = new UnionFind(grid);
      
      for (int i = 0; i < rows; i++) {
          for (int j = 0; j < cols; j++) {
              if (grid[i][j] == '1') {
                  grid[i][j] = '0';
                  if (i - 1 >= 0 && grid[i - 1][j] == '1') {
                      uf.union(i * cols + j, (i - 1) * cols + j);
                  }
                  if (i < rows - 1 && grid[i + 1][j] == '1') {
                      uf.union(i * cols + j, (i + 1) * cols +j);
                  }
                  if (j - 1 >= 0 && grid[i][j - 1] == '1') {
                      uf.union(i * cols + j, i * cols + j - 1);
                  }
                  if (j < cols - 1 && grid[i][j + 1] == '1') {
                      uf.union(i * cols + j, i * cols + j + 1);
                  }
              }
          }
      }
      
      return uf.getCount();
  }
}

lc的solution也贴过来好了：

class Solution {
  class UnionFind {
    int count; // # of connected components
    int[] parent;
    int[] rank;

    public UnionFind(char[][] grid) { // for problem 200
      count = 0;
      int m = grid.length;
      int n = grid[0].length;
      parent = new int[m * n];
      rank = new int[m * n];
      for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
          if (grid[i][j] == '1') {
            parent[i * n + j] = i * n + j;
            ++count;
          }
          rank[i * n + j] = 0;
        }
      }
    }

    public int find(int i) { // path compression
      if (parent[i] != i) parent[i] = find(parent[i]);
      return parent[i];
    }

    public void union(int x, int y) { // union with rank
      int rootx = find(x);
      int rooty = find(y);
      if (rootx != rooty) {
        if (rank[rootx] > rank[rooty]) {
          parent[rooty] = rootx;
        } else if (rank[rootx] < rank[rooty]) {
          parent[rootx] = rooty;
        } else {
          parent[rooty] = rootx; rank[rootx] += 1;
        }
        --count;
      }
    }

    public int getCount() {
      return count;
    }
  }

  public int numIslands(char[][] grid) {
    if (grid == null || grid.length == 0) {
      return 0;
    }

    int nr = grid.length;
    int nc = grid[0].length;
    int num_islands = 0;
    UnionFind uf = new UnionFind(grid);
    for (int r = 0; r < nr; ++r) {
      for (int c = 0; c < nc; ++c) {
        if (grid[r][c] == '1') {
          grid[r][c] = '0';
          if (r - 1 >= 0 && grid[r-1][c] == '1') {
            uf.union(r * nc + c, (r-1) * nc + c);
          }
          if (r + 1 < nr && grid[r+1][c] == '1') {
            uf.union(r * nc + c, (r+1) * nc + c);
          }
          if (c - 1 >= 0 && grid[r][c-1] == '1') {
            uf.union(r * nc + c, r * nc + c - 1);
          }
          if (c + 1 < nc && grid[r][c+1] == '1') {
            uf.union(r * nc + c, r * nc + c + 1);
          }
        }
      }
    }

    return uf.getCount();
  }
}

2020.8.28补充某A公司OA题，跟这题几乎一毛一样，只是这道题用0和1表示，OA用字母表示，同一个字母连在一起就是一个cluster，要求一共有多少个cluster。

重新做这道题发现啥都不记得了，但是看到代码还是马上想起来了。这次稍微自己梳理了一下DFS和BFS的区别，DFS就是往一个方向走了以后就递归DFS一直往那个方向走到走不下去为止，然后再往另一个方向走；BFS就是先把当前这个grid的四个方向都看一遍看看谁一样，一样就放进queue里先，四个方向都看完以后再看看queue里第一个是谁，再接着对它的四个neighbor都看一遍。

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Amazon_NumberOfClusters {
    public static int numberOfClusters(int numOfRows, List<String> grid) {
        if (grid.size() == 0) {
            return 0;
        }
        int result = 0;
        int numOfCols = grid.get(0).length();
        char[][] gridArr = buildGrid(numOfRows, numOfCols, grid);

        for (int i = 0; i < numOfRows; i++) {
            for (int j = 0; j < numOfCols; j++) {
                if (gridArr[i][j] != '0') {
                    result++;
                    dfs(gridArr, i, j);
                }
            }
        }

        return result;
    }

    public static char[][] buildGrid(int numOfRows, int numOfCols, List<String> grid) {
        char[][] gridArr = new char[numOfRows][numOfCols];
        for (int i = 0; i < numOfRows; i++) {
            for (int j = 0; j < numOfCols; j++) {
                gridArr[i][j] = grid.get(i).charAt(j);
            }
        }
        return gridArr;
    }

    public static void dfs(char[][] grid, int i, int j) {
        char cluster = grid[i][j];
//        System.out.println("dfs(" + i + ", " + j + "): " + cluster);
        grid[i][j] = '0';
        if (i - 1 >= 0 && grid[i - 1][j] == cluster) {
            dfs(grid, i - 1, j);
        }
        if (j - 1 >= 0 && grid[i][j - 1] == cluster) {
            dfs(grid, i, j - 1);
        }
        if (i + 1 < grid.length && grid[i + 1][j] == cluster) {
            dfs(grid, i + 1, j);
        }
        if (j + 1 < grid[0].length && grid[i][j + 1] == cluster) {
            dfs(grid, i, j + 1);
        }
    }

    public static int numberOfClustersBFS(int numOfRows, List<String> grid) {
        if (grid.size() == 0) {
            return 0;
        }
        int result = 0;
        int numOfCols = grid.get(0).length();
        char[][] gridArr = buildGrid(numOfRows, numOfCols, grid);

        for (int i = 0; i < numOfRows; i++) {
            for (int j = 0; j < numOfCols; j++) {
                if (gridArr[i][j] != '0') {
                    char cluster = gridArr[i][j];
                    result++;
                    Queue<Integer> neighbors = new LinkedList<>();
                    neighbors.add(i * numOfCols + j);

                    while (!neighbors.isEmpty()) {
                        int coor = neighbors.poll();
                        int row = coor / numOfCols;
                        int col = coor % numOfCols;

                        if (row + 1 < numOfRows && gridArr[row + 1][col] == cluster) {
                            gridArr[row + 1][col] = '0';
                            neighbors.add((row + 1) * numOfCols + col);
                        }
                        if (row - 1 >= 0 && gridArr[row - 1][col] == cluster) {
                            gridArr[row - 1][col] = '0';
                            neighbors.add((row - 1) * numOfCols + col);
                        }
                        if (col + 1 < numOfCols && gridArr[row][col + 1] == cluster) {
                            gridArr[row][col + 1] = '0';
                            neighbors.add(row * numOfCols + col + 1);
                        }
                        if (col - 1 >= 0 && gridArr[row][col - 1] == cluster) {
                            gridArr[row][col - 1] = '0';
                            neighbors.add(row * numOfCols + col - 1);
                        }
                    }
                }
            }
        }

        return result;
    }

    public static void main(String[] args) {
        String[] grid = {"aabba", "aabba", "aaacb"};
        System.out.println(numberOfClustersBFS(3, Arrays.asList(grid)));
    }
}