LeetCode - 684. 冗余连接

描述

在本问题中, 树指的是一个连通且无环的无向图。

输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, ..., N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。

结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。

返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u < v。

示例 1：

输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的无向图为:
  1
 / \
2 - 3
示例 2：

输入: [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]
解释: 给定的无向图为:
5 - 1 - 2
    |   |
    4 - 3
注意:

输入的二维数组大小在 3 到 1000。
二维数组中的整数在1到N之间，其中N是输入数组的大小。
更新(2017-09-26):
我们已经重新检查了问题描述及测试用例，明确图是无向 图。对于有向图详见冗余连接II。对于造成任何不便，我们深感歉意。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/redundant-connection/
 

求解

   class UnionFind {
    public:
        UnionFind(int n) : count(n) {
            parent.reserve(count + 1);
            for (int i = 0; i <= count; ++i) {
                parent[i] = i;
            }
            rank.resize(count + 1, 1);  // 初始每个的层级均为1
        }

        bool isConnected(int p, int q) {
            return find(p) == find(q);
        }

        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;
            } else if (rank[proot] > rank[qroot]) {
                parent[qroot] = proot;
            } else {
                // rank[proot] == rank[qroot]
                parent[proot] = qroot;
                ++rank[qroot];  // proot ”挂载“到qroot下面，本来两个层级一致，现在需要增加1
            }
        }

    private:
        int find(int p) {
            // 效率低，但是相对1e在unionElements中的逐个赋值效率要高
            // 路径压缩优化实例
            // 假设有 4 -> 3 -> 2 -> 1 -> 0的指向，则通过路径压缩优化后变为
            // 1 -> 0
            // 3 -> 2 -> 0
            // 4 -> 2 -> 0
            while (p != parent[p]) {
                parent[p] = parent[parent[p]]; // 路径压缩优化，请细品
                p = parent[p];
            }
            return p;
        }

    private:
        std::vector<int> parent;
        int count;
        std::vector<int> rank;
    };

    class Solution {
    public:
        // 方法一，单独定义一个并查集类辅助实现
        vector<int> findRedundantConnection_1e(vector<vector<int>> &edges) {
            UnionFind uf(edges.size());
            for (auto p  :  edges) {
                if (!uf.isConnected(p[0], p[1])) {
                    uf.unionElements(p[0], p[1]);
                    continue;
                }
                return p;
            }
            return vector<int>(); // 不存在这样的边，返回空
        }

        // 方法二，不定义并查集类，仅实现两个辅助函数
        vector<int> findRedundantConnection(vector<vector<int>> &edges) {
            const int n = edges.size();
            vector<int> parent(n + 1, 0);
            for (int i = 0; i <= n; ++i) {
                parent[i] = i;
            }
            for (auto p : edges) {
                if (!isConnected(parent, p[0], p[1])) {
                    unionElements(parent, p[0], p[1]);
                    continue;
                }
                return p;
            }
            return vector<int>();
        }

    private:
        int find(vector<int> &parent, int p) {
            while (p != parent[p]) {
                parent[p] = parent[parent[p]];
                p = parent[p];
            }
            return p;
        }

        bool isConnected(vector<int> &parent, int p, int q) {
            int pParent = find(parent, p);
            int qParent = find(parent, q);
            return pParent == qParent;
        }

        void unionElements(vector<int> &parent, int p, int q) {
            int pParent = find(parent, p);
            int qParent = find(parent, q);
            if (pParent != qParent) {
                parent[pParent] = qParent;
            }
        }
    };