[leetCode]947. 移除最多的同行或同列石头

题目

https://leetcode-cn.com/problems/most-stones-removed-with-same-row-or-column/

并查集

移除石头的过程其实就是有个逆向深度优先搜索或者广度优先搜索的过程。石子的横坐标相等或纵坐标相等相当于在石子之间形成了边。同一个连通分量的石子一定能移除到只剩下一块，所以题目可以转化为求连通分量的个数，而题目给的输入数组是石子的坐标，因此可以考虑使用并查集。

并查集中「合并」的语义是：
所有横坐标为 x 的石头和所有纵坐标为 y 的石头都属于同一个连通分量。
为了保证一个坐标的x,y不相等需要将一个坐标加上10000,由于不清楚有多少个不同的x，y因此并查集的底层使用了Map

class Solution {
    public int removeStones(int[][] stones) {
        UnionFind unionFind = new UnionFind();
        for (int[] stone : stones) {
            unionFind.union(stone[0] + 10000, stone[1]);
        }
        return stones.length - unionFind.getCount();
    }

    private class UnionFind {
        private Map<Integer, Integer> parent;

        public UnionFind() {
            this.parent = new HashMap();
        }
        private int count = 0;

        public int find(int x) {
            if (!parent.containsKey(x)) {
                parent.put(x, x);
                count++;
            }
            if (x != parent.get(x)) {
                parent.put(x, find(parent.get(x)));
            }
            return parent.get(x);
        }

        public void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);
            if (rootX == rootY) return;
            parent.put(rootX, rootY);
            count--;
        }

        private int getCount() {
            return this.count;
        }
    }
}

深度优先搜索

class Solution {
    public int removeStones(int[][] stones) {
        // 顶点的个数
        int n = stones.length;
        // 顶点的邻接表
        List<List<Integer>> edges = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            edges.add(i, new ArrayList<>());
            for (int j = 0; j < n; j++) {
                if (stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]) {
                    edges.get(i).add(j);
                }
            }
        }
        boolean[] seen = new boolean[n];
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (!seen[i]) {
                count++;
                dfs(i, edges, seen);
            }
        }
        return n - count;
    }

    private void dfs(int x, List<List<Integer>> edges, boolean[] seen) {
        seen[x] = true;
        for (int e :edges.get(x)) {
            if (!seen[e]) {
                dfs(e, edges, seen);
            }
        }
    }
}

优化建图 + 深度优先搜索

注意到任意两点间之间直接相连与间接相连并无影响，即我们只关注两点间的连通性，而不关注具体如何联通。因此考虑对于拥有 k个石子的任意一行或一列，我们都恰使用 k-1条边进行连接。这样我们就可以将边数从 O(n^2) 的数量级降低到O(n)。

这样，我们首先利用哈希表存储每一行或每一列所拥有的石子，然后分别处理每一行或每一列的连通属性即可。

注意到每一个石子的横坐标与纵坐标的范围均在[1,10^4]，因此在实际代码中，我们可以使用同一张哈希表，只需要令纵坐标加 10^4，以区别横坐标与纵坐标即可。

class Solution {
    public int removeStones(int[][] stones) {
        // 顶点的个数
        int n = stones.length;
        // 顶点的邻接表
        List<List<Integer>> edges = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            edges.add(i, new ArrayList<>());
        }
        Map<Integer, List<Integer>> rec = new HashMap<>();
        for (int i = 0; i < n; i++) {
           rec.computeIfAbsent(stones[i][0], k -> new ArrayList<>()).add(i);
           rec.computeIfAbsent(stones[i][1] + 10000, k -> new ArrayList<>()).add(i);
        }
        for (Map.Entry<Integer, List<Integer>> entry : rec.entrySet()) {
            List<Integer> list = entry.getValue();
            // 横坐标或者纵坐标相同的顶点有k个，使用k-1条边将其相连 x---x---x---x 4个顶点3条边
            int k = list.size();
            for (int i = 1; i < k; i++) {
                edges.get(list.get(i-1)).add(list.get(i));
                edges.get(list.get(i)).add(list.get(i-1));
            }
        }
        boolean[] seen = new boolean[n];
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (!seen[i]) {
                count++;
                dfs(i, edges, seen);
            }
        }
        return n - count;
    }

    private void dfs(int x, List<List<Integer>> edges, boolean[] seen) {
        seen[x] = true;
        for (int e :edges.get(x)) {
            if (!seen[e]) {
                dfs(e, edges, seen);
            }
        }
    }
}