Most Stones Removed with Same Row or Column

On a 2D plane, we place stones at some integer coordinate points.  Each coordinate point may have at most one stone.

Now, a move consists of removing a stone that shares a column or row with another stone on the grid.

What is the largest possible number of moves we can make?

Example 1:

Input: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
Output: 5

Example 2:

Input: stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
Output: 3

Example 3:

Input: stones = [[0,0]]
Output: 0

Note:

1. 1 <= stones.length <= 1000
2. 0 <= stones[i][j] < 10000

思路：题目就是求有多少个connect component，因为每个connect component最后只剩下一个；那么就是总共点数 - # of Connect Component; 这题可以用DFS, BFS, Union-Find都可以做；Union Find Time: N^2*logN;

class Solution {
    private class UnionFind {
        private int[] father;
        private int count;
        
        public UnionFind(int n) {
            this.father = new int[n + 1];
            for(int i = 0; i <= n; i++) {
                father[i] = i;
            }
            this.count = n;
        }
        
        public int find(int x) {
            int j = x;
            while(father[j] != j) {
                j = father[j];
            }
            
            // path compression;
            while(x != j) {
                int fx = father[x];
                father[x] = j;
                x = fx;
            }
            return j;
        }
        
        public void union(int a, int b) {
            int root_a = find(a);
            int root_b = find(b);
            if(root_a != root_b) {
                father[root_a] = root_b;
                this.count--;
            }
        }
        
        public int getCount() {
            return this.count;
        }
    }
    
    public int removeStones(int[][] stones) {
        int n = stones.length;
        UnionFind uf = new UnionFind(n);
        for(int i = 0; i < n; i++) {
            for(int j = i + 1; j < n; j++) {
                if(isconnect(i, j, stones)) {
                    uf.union(i, j);
                }
            }
        }
        return n - uf.getCount();
    }
    
    private boolean isconnect(int x, int y, int[][] stones) {
        return (stones[x][0] == stones[y][0]) || (stones[x][1] == stones[y][1]);
    }
}

 用DFS来做，Time : O(N^2);

class Solution {
    public int removeStones(int[][] stones) {
        HashSet<int[]> visited = new HashSet<>();
        int n = stones.length;
        int count = 0;
        for(int[] p: stones) {
            if(!visited.contains(p)) {
                dfs(p, stones, visited);
                count++;
            }
        }
        return n - count;
    }
    
    private void dfs(int[] p, int[][] stones, HashSet<int[]> visited) {
        visited.add(p);
        for(int[] p2: stones) {
            if(!visited.contains(p2)) {
                if(p[0] == p2[0] || p[1] == p2[1]) {
                    dfs(p2, stones, visited);
                }
            }
        }
    }
}