LeetCode - 947. 移除最多的同行或同列石头

描述

n 块石头放置在二维平面中的一些整数坐标点上。每个坐标点上最多只能有一块石头。

如果一块石头的 同行或者同列 上有其他石头存在，那么就可以移除这块石头。

给你一个长度为 n 的数组 stones ，其中 stones[i] = [xi, yi] 表示第 i 块石头的位置，返回 可以移除的石子 的最大数量。

 

示例 1：

输入：stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]
输出：5
解释：一种移除 5 块石头的方法如下所示：
1. 移除石头 [2,2] ，因为它和 [2,1] 同行。
2. 移除石头 [2,1] ，因为它和 [0,1] 同列。
3. 移除石头 [1,2] ，因为它和 [1,0] 同行。
4. 移除石头 [1,0] ，因为它和 [0,0] 同列。
5. 移除石头 [0,1] ，因为它和 [0,0] 同行。
石头 [0,0] 不能移除，因为它没有与另一块石头同行/列。
示例 2：

输入：stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]
输出：3
解释：一种移除 3 块石头的方法如下所示：
1. 移除石头 [2,2] ，因为它和 [2,0] 同行。
2. 移除石头 [2,0] ，因为它和 [0,0] 同列。
3. 移除石头 [0,2] ，因为它和 [0,0] 同行。
石头 [0,0] 和 [1,1] 不能移除，因为它们没有与另一块石头同行/列。
示例 3：

输入：stones = [[0,0]]
输出：0
解释：[0,0] 是平面上唯一一块石头，所以不可以移除它。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/most-stones-removed-with-same-row-or-column/

求解

    // 使用散列表实现一个动态增加的并查集
    class VarUnionFind {
    private:
        unordered_map<int, int> parent;
        unordered_map<int, int> rank;
    public:
        int find(int p) {
            if (parent.count(p) == 0) {
                // 如果p在散列表中不存在，则添加进去
                parent[p] = p;
                return p;
            }
            while (p != parent[p]) {
                parent[p] = parent[parent[p]];
                p = parent[p];
            }
            return p;
        }

        void unionElements(int p, int q) {
            int pRoot = find(p);
            int qRoot = find(q);
            if (pRoot == qRoot) {
                return;
            }
            if (rank[pRoot] < rank[qRoot]) {
                parent[pRoot] = qRoot;
                return;
            }
            if (rank[pRoot] > rank[qRoot]) {
                parent[qRoot] = pRoot;
                return;
            }
            // rank[pRoot] == rank[qRoot]
            parent[pRoot] = qRoot;
            ++rank[qRoot];
        }

        // 返回并查集的连通分量
        int getConnectedComponent() {
            int count = 0;
            for (auto &[p, root] : parent) {
                if (p == root) {
                    ++count;
                }
            }
            return count;
        }
    };

    class Solution {
    public:
        // 方法一，使用并查集，求取连通分量，通过分析可知，每个连通分量通过不停的粉碎可以只剩下一块石头
        // 则结果为n - 连通分量个数
        int removeStones_useUnionFind(vector<vector<int>> &stones) {
            const int OFFSET = 100001; // 纵坐标的偏移量，为了不跟横坐标重合的冲突
            VarUnionFind uf;
            for (auto &vec : stones) {
                uf.unionElements(vec[0], vec[1] + OFFSET);
            }
            // 石头数量减去并查集的连通分量即为可以粉碎的最大数量石头
            return stones.size() - uf.getConnectedComponent();
        }

        // 方法二，深度遍历图得到连通分量，这里将每块石头看做图的一个结点，通过观察是否在同行或者同列来确定是否有边相连，
        // 最后通过深度遍历计算连通分量，则结果为n - 连通分量个数
        int removeStones_useDFS1e(vector<vector<int>> &stones) {
            const int n = stones.size();
            vector<vector<int>> edges(n, vector<int>());  // 邻接表存储图
            // 构造图
            for (int i = 0; i < n; ++i) {
                for (int j = i + 1; j < n; j++) {
                    if (stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]) {
                        edges[i].push_back(j);
                        edges[j].push_back(i);  // 构造一个无向图
                    }
                }
            }

            // 深度遍历，求取连通分量
            int count = 0;  // 连通分量初始化为0
            visited.assign(n, false); // 结点访问标记初始化
            for (int i = 0; i < n; ++i) {
                if (!visited[i]) {
                    ++count;
                    dfs(edges, i);
                }
            }
            return n - count;
        }

        // 方法三，方法二建图部分时间复杂度为O(N*N)，进行优化，将同行或者同列的石头放一起，再进行建图
        int removeStones(vector<vector<int>> &stones) {
            const int n = stones.size();
            const int OFFSET = 100001; // 纵坐标的偏移量，为了不跟横坐标重合的冲突
            unordered_map<int, vector<int>> record;
            // 计算每个行或者列上有哪些石头（图节点）
            for (int i = 0; i < n; ++i) {
                record[stones[i][0]].emplace_back(i);  // 在横坐标stones[i][0]上有石头i（即图节点i ）
                record[stones[i][1] + OFFSET].emplace_back(i);  // 在横坐标stones[i][1] + OFFSET上有石头i（即图节点i ）
            }

            // 构造图
            vector<vector<int>> edges(n, vector<int>());  // 邻接表构造图
            for (auto &[_, vec] : record) {
                int k = vec.size();
                for (int i = 1; i < k; ++i) {
                    // 在同行或者同列的节点肯定相连，注意无向图的处理
                    edges[vec[i - 1]].emplace_back(vec[i]);
                    edges[vec[i]].emplace_back(vec[i - 1]);
                }
            }

            // 深度遍历，求取连通分量
            int count = 0;  // 连通分量初始化为0
            visited.assign(n, false); // 结点访问标记初始化
            for (int i = 0; i < n; ++i) {
                if (!visited[i]) {
                    ++count;
                    dfs(edges, i);
                }
            }
            return n - count;
        }

    private:
        // 图的深度遍历
        void dfs(const vector<vector<int>> &edges, int v) {
            visited[v] = true;
            const auto &adjPoints = edges[v];
            for (auto w : adjPoints) {
                if (!visited[w]) {
                    dfs(edges, w);
                }
            }
        }

        // 图结点是否访问标志，用于辅助遍历
        vector<bool> visited;
    };