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