Leetcode solution 200. Number of Islands (Using BFS, DFS & Disjoint Set)

Problem Statement 

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

 Problem link

Video Tutorial

You can find the detailed video tutorial here

• Youtube BFS & DFS solution in 2015
• Youtube Disjoint Solution
• B站

Thought Process

I have recorded a video back in 2015 (5 years ago, Geez time flies) using BFS and DFS. The essential idea is every time we see a land (i.e., "1"), we would trigger a BFS or DFS search to mark all the connected grids and increase the island counts to 1.

 

Another solution is to use Disjoint Set (aka Union Find). There is a generic solution where we could implement a DisjointSet data structure and perform "union" steps first to assign each grid a "parent". In the 2nd iteration we can perform "find" step to count how many distinct "parents", which is the number of islands.

 

A quick summary of some classic use cases

• Disjoint Set / Union Find (Disjoint set is the data structure while union find is the algorithm, people normally use it interchangeably)  can often be used to solve if a graph is connected or not, such as phone contact problem (who knows who, how many isolated groups are there)
• To detect if a directed graph has cycle, use Kahn's algorithm for topological sort
• To detect if a un-directed graph has cycle
• We could use normal BFS or DFS
• We should use Union Find with edge list graph representation

 

Solutions

Use BFS

public class Block {
    public int x;
    public int y;

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

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

    int m = grid.length;
    int n = grid[0].length;

    boolean[][] visited = new boolean[m][n];
    int count = 0;

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == '0' || visited[i][j]) {
                continue;
            }

            count++;
            visited[i][j] = true;

            Queue<Block> q = new LinkedList<>(); // queue just uses LinkedList, ArrayList doesn't implement it

            // remind myself what's the diff between offer and add, 
            // some implementation it's the same, some add throws while offer return true/false if the queue is
            // full while you still trying to add
            q.offer(new Block(i, j)); 

            while (!q.isEmpty()) {
                Block b = q.poll();

                for (int k = 0; k < 4; k++) {
                    int x = b.x + xDirection[k];
                    int y = b.y + yDirection[k];
                    if (this.shouldExplore(x, y, m, n, grid, visited)) {
                        visited[x][y] = true;
                        q.offer(new Block(x, y));
                    }
                }
            }
        }
    }
    return count;
}

private boolean shouldExplore(int x, int y, int row, int col, char[][] grid, boolean[][] visited) {
    if (x >= 0 && x < row && y >= 0 && y < col && grid[x][y] == '1' && !visited[x][y]) return true;

    return false;
}

 

Time Complexity: O(M*N), where M and N is row and col of grid matrix. Each grid is visited once
Space Complexity: O(M*N) since we have to track the visited grid 

Use DFS

private final int[] xDirection = {1, 0, -1, 0};
private final int[] yDirection = {0, -1, 0, 1 };

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

    int m = grid.length;
    int n = grid[0].length;
    int islandCount = 0;
    boolean[][] visited = new boolean[m][n];

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == '0' || visited[i][j]) {
                continue;
            }
            explore(i, j, m, n, grid, visited);
            islandCount++;
        }
    }

    return islandCount;
}

private void explore(int x, int y, int row, int col, char[][] grid, boolean[][] visited) {
    if (!this.shouldExplore(x, y, row, col, grid, visited)) return;

    visited[x][y] = true;
    for (int i = 0; i < 4; i++) {
        explore(x + this.xDirection[i], y + this.yDirection[i], row, col, grid, visited);
    }
}

 

Time Complexity: O(M*N), where M and N is row and col of grid matrix. Each grid is visited once
Space Complexity: O(M*N) since we have to track the visited grids

 

Use Disjoint Set / Union Find

private class DisjointSet {
    private Map<String, String> lookup = new HashMap<>();

    public void init(int row, int col) {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                String key  = i + "," + j;
                // initially key value is the same, meaning the parent of the disjoint set is itself, i.e., isolated or not initialized
                this.lookup.put(key, key);
            }
        }
    }

    /**
     * @param key "row,col" is the key in the mastrix
     * @return String, "row,col" of the parent of this key
     */
    public String find(String key) throws Exception {
        if (key == null || key.length() == 0 || !this.lookup.containsKey(key)) {
            throw new Exception(String.format("Invalid input key %s", key));
        }

        while (!key.equals(this.lookup.get(key))) {
            key = this.lookup.get(key);
        }

        return key;
    }

    public void union(String key1, String key2) throws Exception {
        if (key1 == null || key1.length() == 0 || key2 == null || key2.length() == 0) {
            throw new Exception(String.format("key1 %s or key2 %s not valid", key1, key2));
        }

        String parent1 = this.find(key1);
        String parent2 = this.find(key2);

        if (!parent1.equals(parent2)) {
            this.lookup.put(parent1, parent2);
        }
    }

}

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

    int row = grid.length;
    int col = grid[0].length;
    // key: row,col, val: row,col
    DisjointSet ds = new DisjointSet();
    ds.init(row, col);
    Set<String> islands = new HashSet<>();

    try {
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == '1') {
                    String key = i + "," + j;
                    // union right grid
                    if (j + 1 < col && grid[i][j + 1] == '1') {
                        ds.union(key, i + "," + (j + 1));
                    }
                    // union the below grid
                    if (i + 1 < row && grid[i + 1][j] == '1') {
                        ds.union(key, (i + 1) + "," + j);
                    }
                }
            }
        }

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == '1') {
                    islands.add(ds.find(i + "," + j));
                }
            }
        }
    } catch (Exception e) {
        System.err.println(e);
    }
    return islands.size();
}

 

Time Complexity: O(M*N), where M and N is row and col of grid matrix. Each grid is visited once
Space Complexity: O(M*N) since we have to track the visited grids using a map

References

• Leetcode official solution