Leetcode: 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 <= stones.length <= 1000
0 <= stones[i][j] < 10000

If stone a and stone b are in the same column/row, we connect them as a component

The largest possible number of moves we can make = the number of unions we can make = Total stones count - count of components.

class Solution {
    public int removeStones(int[][] stones) {
        UnionFind uf = new UnionFind(stones.length);
        int countUnion = 0;
        for (int i = 0; i < stones.length - 1; i ++) {
            for (int j = i + 1; j < stones.length; j ++) {
                if (uf.isConnected(i, j)) continue;
                if (stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]) {
                    uf.union(i, j);
                    countUnion ++;
                }
            }
        }
        return countUnion;
    }
    
    public class UnionFind {
        int[] fathers;
        
        public UnionFind(int n) {
            fathers = new int[n];
            for (int i = 0; i < n; i ++) {
                fathers[i] = i;
            }
        }
        
        public void union(int i, int j) {
            int iRoot = find(i);
            int jRoot = find(j);
            fathers[jRoot] = iRoot;
        }
        
        public int find(int i) {
            while (i != fathers[i]) {
                i = fathers[i];
            }
            return i;
        }
        
        public boolean isConnected(int i, int j) {
            return find(i) == find(j);
        }
    }
}