#leetcode#305. Number of Islands II

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;
    }
}