移除最多的同行或同列石头

/*
 * 思路：
 * 使用 Java Stream API 的同样逻辑来实现并查集。
 * 我们可以使用 Arrays.stream 和 mapToObj 创建 Stone 对象的流，
 * 然后使用 Collectors.toMap 将它们按索引进行收集，
 * 最后使用同样的并查集算法来计算可移除的石头数量。
 */

import java.util.*;
import java.util.stream.*;

class Solution {
    public int removeStones(int[][] stones) {
        Map<Integer, int[]> stoneMap = IntStream.range(0, stones.length)
            .boxed()
            .collect(Collectors.toMap(i -> i, i -> stones[i]));
        UnionFind uf = new UnionFind(stones.length);
        stoneMap.forEach((i, stone1) -> {
            stoneMap.forEach((j, stone2) -> {
                if (i < j && (stone1[0] == stone2[0] || stone1[1] == stone2[1])) {
                    uf.union(i, j);
                }
            });
        });
        return stones.length - uf.getCount();
    }

    class UnionFind {
        private int[] parent;
        private int count;

        public UnionFind(int n) {
            parent = new int[n];
            count = n;
            IntStream.range(0, n).forEach(i -> parent[i] = i);
        }

        public int find(int x) {
            if (parent[x] != x) {
                parent[x] = find(parent[x]);
            }
            return parent[x];
        }

        public void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);
            if (rootX != rootY) {
                parent[rootX] = rootY;
                count--;
            }
        }

        public int getCount() {
            return count;
        }
    }
}