200. 岛屿数量 (递归 / 并查集)

思路

递归

并查集

代码实现

递归

class Solution {
    // 递归写法(最优解)
    public int numIslands(char[][] grid) {
        int isLand = 0;
        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[i].length; j++) {
                if(grid[i][j] == '1') {
                    isLand++; 
                    infect(grid, i, j);
                }
            }
        }
        return isLand;
    }

    public void infect(char[][] grid, int i, int j) {
        // 判断是否越界
        if(i < 0 || i == grid.length || j < 0 || j == grid[0].length || grid[i][j] != '1') {
            return;
        }
        // 感染它的上下左右，并递归的进行感染
        grid[i][j] = 0;
        infect(grid, i - 1, j);
        infect(grid, i + 1, j);
        infect(grid, i, j - 1);
        infect(grid, i, j + 1);
    }
}

map集合实现并查集

class Solution {
    // 并查集(map实现方式)方法
    public int numIslands(char[][] grid) {
        int row = grid.length;
        int col = grid[0].length;
        Dot[][] dots = new Dot[row][col];
        // 用于创建并查集节点
        List<Dot> dotList = new ArrayList<>();
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == '1') {
                    dots[i][j] = new Dot();
                    dotList.add(dots[i][j]);
                }
            }
        }

        // 创建并查集
        UnionFind<Dot> uf = new UnionFind<>(dotList);
        // 先判断第一行
        for (int j = 1; j < col; j++) {
            if (grid[0][j-1] == '1' && grid[0][j] == '1') {
                uf.union(dots[0][j-1], dots[0][j]);
            }
        }

        // 再判断第一列
        for (int i = 1; i < row; i++) {
            if (grid[i - 1][0] == '1' && grid[i][0] == '1') {
                uf.union(dots[i-1][0], dots[i][0]);
            }
        }

        // 最后判断中间的常规节点
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                if (grid[i][j] == '1') {
                    // 左边是不是 1
                    if (grid[i][j - 1] == '1') {
                        uf.union(dots[i][j - 1], dots[i][j]);
                    }
                    // 上边是不是 1
                    if (grid[i - 1][j] == '1') {
                        uf.union(dots[i - 1][j], dots[i][j]);
                    }
                }
            }
        }

        return uf.sets();
    }

    // 用来在并查集中区分不同的 1
    public class Dot {

    }

    public static class Node<V> {
        V value;
        public Node(V v) {
            value = v;
        }
    }

    // 并查集 map集合实现
    public class UnionFind<V> {
        public HashMap<V, Node<V>> nodes;
        public HashMap<Node<V>, Node<V>> parents;
        public HashMap<Node<V>, Integer> sizeMap;

        public UnionFind(List<V> values) {
            nodes = new HashMap<>();
            parents = new HashMap<>();
            sizeMap = new HashMap<>();
            for (V cur : values) {
                Node<V> node = new Node<>(cur);
                nodes.put(cur, node);
                parents.put(node, node);
                sizeMap.put(node, 1);
            }
        }

        // 找到代表节点，并压缩路径
        public Node<V> findFather(Node<V> cur) {
            Stack<Node<V>> path = new Stack<>();
            while (cur != parents.get(cur)) {
                path.push(cur);
                cur = parents.get(cur);
            }
            while (!path.isEmpty()) {
                parents.put(path.pop(), cur);
            }
            return cur;
        }

        // 合并集合
        public void union(V a, V b) {
            Node<V> aHead = findFather(nodes.get(a));
            Node<V> bHead = findFather(nodes.get(b));
            if (aHead != bHead) {
                int aSize = sizeMap.get(aHead);
                int bSize = sizeMap.get(bHead);
                Node<V> big = aSize >= bSize ? aHead : bHead;
                Node<V> small = big == aHead ? bHead : aHead;
                parents.put(small, big);
                sizeMap.put(big, aSize + bSize);
                sizeMap.remove(small);
            }
        }

        public int sets() {
            return sizeMap.size();
        }
    }
}

数组实现并查集

class Solution {
    // 数组方式实现并查集
    public int numIslands(char[][] grid) {
        int row = grid.length;
        int col = grid[0].length;
        UnionFind uf = new UnionFind(grid);

        // 合并流程
        // 先判断第一行
        for (int i = 1; i < col; i++) {
            if (grid[0][i - 1] == '1' && grid[0][i] == '1') {
                uf.union(0, i - 1, 0, i);
            }
        }
        // 再判断第一列
        for (int i = 1; i < row; i++) {
            if (grid[i - 1][0] == '1' && grid[i][0] == '1') {
                uf.union(i - 1, 0, i, 0);
            }
        }

        // 最后判断中间的普通节点
        for (int i = 1; i < row; i++) {
            for (int j = 1; j < col; j++) {
                if (grid[i][j] == '1') {
                    // 上方是否为 1
                    if (grid[i - 1][j] == '1') {
                        uf.union(i-1, j, i, j);
                    }
                    // 左边是否为 1
                    if (grid[i][j - 1] == '1') {
                        uf.union(i, j - 1, i, j);
                    }
                }
            }
        }

        return uf.sets();
    }

    public class UnionFind {
        private int[] parent;  // 代表节点
        private int[] size;   // 代表节点下集合大小
        private int[] help;   // 代替栈
        private int col;      // 列数
        private int sets;     // 集合数量，就是本题答案

        public UnionFind(char[][] board) {
            col = board[0].length;
            sets = 0;
            int row = board.length;
            int len = row * col;
            // 初始化各个数组的大小为行乘列
            parent = new int[len];
            size = new int[len];
            help = new int[len];
            for (int r = 0; r < row; r++) {
                for (int c = 0; c < col; c++) {
                    if (board[r][c] == '1') {
                        int i = index(r, c);
                        parent[i] = i;
                        size[i] = 1;
                        sets++;
                    }
                }
            }
        }

        public int index(int r, int c) {
            return r * col + c;
        }

        private int find(int i) {
            int hi = 0;
            while(i != parent[i]) {
                help[hi++] = i;
                i = parent[i];
            }
            for (hi--; hi >= 0; hi--) {
                parent[help[hi]] = i;
            }
            return i;
        }

        public void union(int r1, int c1, int r2, int c2) {
            int i1 = index(r1, c1);
            int i2 = index(r2, c2);
            // 得到代表节点的下标
            int f1 = find(i1);
            int f2 = find(i2);
            if (f1 != f2) {
                if (size[f1] > size[f2]) {
                    size[f1] += size[f2];
                    parent[f2] = f1;
                } else {
                    size[f2] += size[f1];
                    parent[f1] = f2;
                }
                sets--;
            }
        }

        public int sets() {
            return sets;
        }
    }
}