LeetCode 959. Regions Cut By Slashes

原题链接在这里：https://leetcode.com/problems/regions-cut-by-slashes/

题目：

In a N x N grid composed of 1 x 1 squares, each 1 x 1 square consists of a /, \, or blank space.  These characters divide the square into contiguous regions.

(Note that backslash characters are escaped, so a \ is represented as "\\".)

Return the number of regions.

Example 1:

Input:
[
  " /",
  "/ "
]
Output: 2
Explanation: The 2x2 grid is as follows:

Example 2:

Input:
[
  " /",
  "  "
]
Output: 1
Explanation: The 2x2 grid is as follows:

Example 3:

Input:
[
  "\\/",
  "/\\"
]
Output: 4
Explanation: (Recall that because \ characters are escaped, "\\/" refers to \/, and "/\\" refers to /\.)
The 2x2 grid is as follows:

Example 4:

Input:
[
  "/\\",
  "\\/"
]
Output: 5
Explanation: (Recall that because \ characters are escaped, "/\\" refers to /\, and "\\/" refers to \/.)
The 2x2 grid is as follows:

Example 5:

Input:
[
  "//",
  "/ "
]
Output: 3
Explanation: The 2x2 grid is as follows:

Note:

1. 1 <= grid.length == grid[0].length <= 30
2. grid[i][j] is either '/', '\', or ' '.

题解：

If one grid is divided by both '/' and '\\', then it could be 4 regions.

Mark them as 0,1,2,3 for top, right, bottom and left part.

If there is no '/', then 0 and 1 are unioned, 2 and 3 are unioned. 

If there is no '\\', then 0 and 3 are unioned, 1 and2 are unioned.

For two adjacent grids, left grid part 1 and right grid part 3 are unioned. top grid part 2 and bottom grid part 0 are unioned.

Finally return unions count.

Time Complexity: O(n^2logn). n = grid.length. find takes O(log(n^2)) = O(logn). With path compression and union by weight, amatorize O(1).

Space: O(n^2).

AC Java:

class Solution {
    int [] parent;
    int [] size;
    int count;
    int n;
    
    public int regionsBySlashes(String[] grid) {
        if(grid == null || grid.length == 0){
            return 0;
        }
        
        n = grid.length;
        parent = new int[n*n*4];
        size = new int[n*n*4];
        count = n*n*4;
        
        for(int i = 0; i<n*n*4; i++){
            parent[i] = i;
            size[i] = 1;
        }
        
        for(int i = 0; i<n; i++){
            for(int j = 0; j<n; j++){
                if(i > 0){
                    union(getIndex(i-1, j, 2), getIndex(i, j, 0));
                }
                
                if(j > 0){
                    union(getIndex(i, j-1, 1), getIndex(i, j, 3));
                }
                
                if(grid[i].charAt(j) != '/'){
                    union(getIndex(i, j, 0), getIndex(i, j, 1));
                    union(getIndex(i, j, 2), getIndex(i, j, 3));
                }
                
                if(grid[i].charAt(j) != '\\'){
                    union(getIndex(i, j, 0), getIndex(i, j, 3));
                    union(getIndex(i, j, 1), getIndex(i, j, 2));
                }
            }
        }
        
        return count;
    }
    
    private void union(int i, int j){
        int p = find(i);
        int q = find(j);
        if(p != q){
            if(size[p] > size[q]){
                parent[q] = p;
                size[p] += size[q];
            }else{
                parent[p] = q;
                size[q] += size[p];
                
            }
            
            count--;
        }
    }
    
    private int find(int i){
        while(i != parent[i]){
            parent[i] = parent[parent[i]];
            i = parent[i];
        }
        
        return parent[i];
    }
    private int getIndex(int i, int j, int k){
        return (i*n+j)*4+k;
    }
}