题目：
同样是岛的问题，但是参数有所变化，一共3个参数，m、n、int[][] position。根据position，求出每一步的岛屿的数量。
代表的意思是：m * n是二维数组的行和列，通过 m * n可以构建一个值都为0的二维数组。
而position的值代表着m,n构建的二维数组中对应下标处的值改为1。position[i][j] 代表着mn数组的行和列
举例：

如图所示：m = 3，n = 4，通过m和n构建出来一个3行4列的值都为0的数组。
position的值为[0][0]，[0][1]，[1][1]，mn数组根据position动态改变了，根据position的不同，求出每一步的岛屿的数量。

并查集解法
岛屿数量解法一的帖子中介绍过感染的解法，但是这道题用感染的解法是做不出来的。如果第一次将值“”感染“”后，下一次position的值在上下左右，合并不了了，会变成2个或多个岛屿。
所以这道题只能用并查集的方式来解答，并且和前两篇帖子的解答方式也不大相同。因为position是动态的。

分析

1. 同样采用二维数组拉伸为一维数组的方式，通过mn来确定一维数组的长度。
2. 不进行初始化赋值操作，因为position是动态的，不知道position中的值都有什么，所以不进行初始化操作。
3. 利用size变量，通过size变量的值，来确定该位置是否经历过初始化，如果没有，则进行对应位置的初始化操作，并union上下左右，看是否有“1”可以连成一篇岛屿。

public static List<Integer> numIslands21(int m, int n, int[][] positions) {
        UnionFind uf = new UnionFind(m,n);
        List<Integer> ans = new ArrayList<>();
        for (int[] position : positions){
            ans.add(uf.connect(position[0],position[1]));
        }
        return ans;
    }

    public static class UnionFind {
        int[] parent;
        int[] size;
        int[] help;
        final int col;
        final int row;
        int sets;

        public UnionFind(int m, int n) {
            int len = m * n;
            parent = new int[len];
            size = new int[len];
            help = new int[len];
            col = n;
            row = m;
            sets = 0;
        }

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

        public int findParent(int index) {
            int num = 0;
            while (index != parent[index]) {
                help[num++] = index;
                index = parent[index];
            }
            for (int i = 0; i < num; i++) {
                parent[help[i]] = index;
            }
            return index;
        }

        public int connect(int r, int c) {
            int index = index(r, c);
            if (size[index] == 0) {
                parent[index] = index;
                size[index] = 1;
                sets++;
                union(r, c, r - 1, c);
                union(r, c, r + 1, c);
                union(r, c, r, c - 1);
                union(r, c, r, c + 1);
            }
            return sets;
        }

        public void union(int r1, int c1, int r2, int c2) {
            if (r1 < 0 || r1 == row || r2 < 0 || r2 == row || c1 < 0 || c1 < col || c2 < 0 || c2 < col) {
                return;
            }
            int i1 = index(r1, c1);
            int i2 = index(r2, c2);
            //如果size[i] == 0,说明该位置没初始化过。
            if (size[i1] == 0 || size[i2] == 0) {
                return;
            }

            int f1 = findParent(i1);
            int f2 = findParent(i2);
            if (f1 != f2) {
                if (size[i1] >= size[i2]) {
                    size[i1] += size[i2];
                    parent[i2] = f1;
                } else {
                    size[i2] += size[i1];
                    parent[i1] = f2;
                }
                sets--;
            }
        }
    }