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

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

         }

     }

 }