LeetCode 947. Most Stones Removed with Same Row or Column

原题链接在这里：https://leetcode.com/problems/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

题解：

The number of most stones removed = stones count - unions count

If a stone in on a row or column same as other stone, then two stones are in the same union.

Use two HashMap to maintain row and column to stone index relationship. If the key already exist, then there is previous stone with same row or column existing already.

Find parents of two stones, if they are not equal, then union.

Time Complexity: O(nlogn). find takes O(logn). Since use path compression and union by size, amortize O(1).

Space: O(n).

AC Java:

 class Solution {
     Map<Integer, Integer> row = new HashMap<>();
     Map<Integer, Integer> colum = new HashMap<>();
     int [] parent;
     int [] size;

     public int removeStones(int[][] stones) {
         int n = stones.length;
         parent = new int[n];
         size = new int[n];
         for(int i = 0; i<n; i++){
             parent[i] = i;
             size[i] = 1;
         }

         int count = n;

         for(int i = 0; i<n; i++){

             int [] stone = stones[i];

             if(!row.containsKey(stone[0])){
                 row.put(stone[0], i);
             }else{
                 int p = row.get(stone[0]);
                 if(!find(i, p)){
                     union(i, p);
                     count--;
                 }

             }

             if(!colum.containsKey(stone[1])){
                 colum.put(stone[1], i);
             }else{
                 int p = colum.get(stone[1]);
                 if(!find(i, p)){
                     union(i, p);
                     count--;
                 }
             }

         }

         return n - count;
     }

     private boolean find(int i, int j){
         return root(i) == root(j);
     }

     private int root(int i){
         while(i != parent[i]){
             parent[i] = parent[parent[i]];
             i = parent[i];
         }

         return i;
     }

     private void union(int i, int j){
         int p = root(i);
         int q = root(j);
         if(size[p] > size[q]){
             parent[q] = p;
             size[p] += size[q];
         }else{
             parent[p] = q;
             size[q] += size[p];
         }
     }
 }