A 2d grid map of m rows andn columns is initially filled with water. We may perform anaddLand operation which turns the water at position (row, col) into a land. Given a list of positions to operate,count the number of islands after each addLand operation. 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:

Given m = 3, n = 3,positions = [[0,0], [0,1], [1,2], [2,1]].

Initially, the 2d grid grid is filled with water. (Assume 0 represents water and 1 represents land).

0 0 0

0 0 0

0 0 0

Operation #1: addLand(0, 0) turns the water at grid[0][0] into a land.

1 0 0

0 0 0   Number of islands = 1

0 0 0

Operation #2: addLand(0, 1) turns the water at grid[0][1] into a land.

1 1 0

0 0 0   Number of islands = 1

0 0 0

Operation #3: addLand(1, 2) turns the water at grid[1][2] into a land.

1 1 0

0 0 1   Number of islands = 2

0 0 0

Operation #4: addLand(2, 1) turns the water at grid[2][1] into a land.

1 1 0

0 0 1   Number of islands = 3

0 1 0

We return the result as an array: [1, 1, 2, 3]

====================================================================================

又是一道會了不難的題，考察Union Find，一個find， 一個union 兩個操作，現學了一下， 程式碼沒有怎麼整理， 注意

public class Solution {
    public List<Integer> numIslands2(int m, int n, int[][] positions) {
        List<Integer> res = new ArrayList<>();
        if(positions == null || m < 0 || n < 0)
            return res;
        int[] xOffset = new int[]{0,1,-1,0};
        int[] yOffset = new int[]{1,0,0,-1};
        int[] roots = new int[m * n];
        Arrays.fill(roots, -1);
        for(int i = 0; i < positions.length; i++){
            int count = i == 0 ? 1 : res.get(res.size() - 1) + 1;
            int idx = n * positions[i][0] + positions[i][1];
            roots[idx] = idx;
            for(int j = 0; j < 4; j++){
                int x = positions[i][0] + xOffset[j];
                int y = positions[i][1] + yOffset[j];
                int neighborIdx = n * x + y;
                if(x < 0 || x >= m || y < 0 || y >= n || roots[neighborIdx] == -1)
                    continue;
                
                // if(find(roots, neighborIdx) != idx){
                //     roots[neighborIdx] = idx;          這個block是我一開始想當然的程式碼， 這裡就是union的部分，所謂union是要把part 1的root 設定成part 2的root， 要不然的話你只是union了當前neighbor和當前插入點
                //     count--;
                // }
                int neighborRoot = find(roots, neighborIdx);
                int curRoot = roots[idx];  // here curRoot == idx, but it helps us better understand the comparison below
                // if(neighborRoot != curRoot){ // we are comparing the root of current position and the root of it's neighbor
                //     roots[neighborRoot] = curRoot;
                // }
                // count--;
                if(neighborRoot != curRoot){ // here curRoot equals to idx, we always set current position's root to current idx value;
                    count--;
                    roots[neighborRoot] = curRoot;
                }
                
                
            }
            
            res.add(count);
        }
        
        return res;
    }
    
    private int find(int[] arr, int target){
        if(arr[target] == target)
            return target;
        arr[target] = find(arr, arr[target]);   // here is an optimization
        return arr[target];
        // while(arr[target] != target){
        //     target = arr[target];
        // }
        // return target;
    }
}