Leetcode684. 冗余连接

Every day a Leetcode

题目来源：684. 冗余连接

解法1：并查集

因为需要判断是否两个节点被重复连通，所以我们可以使用并查集来解决此类问题。

代码：

/*
 * @lc app=leetcode.cn id=684 lang=cpp
 *
 * [684] 冗余连接
 */

// @lc code=start
class UnionFind
{
    
    
    vector<int> father, size;

public:
    UnionFind(int n) : father(n), size(n, 1)
    {
    
    
        // iota函数可以把数组初始化为 0 到 n-1
        iota(father.begin(), father.end(), 0);
    }
    int find(int x)
    {
    
    
        while (x != father[x])
        {
    
    
            // 路径压缩，使得下次查找更快
            father[x] = father[father[x]];
            x = father[x];
        }
        return x;
    }
    void connect(int p, int q)
    {
    
    
        int i = find(p), j = find(q);
        if (i != j)
        {
    
    
            // 按秩合并：每次合并都把深度较小的集合合并在深度较大的集合下面
            if (size[i] < size[j])
            {
    
    
                father[i] = j;
                size[j] += size[i];
            }
            else
            {
    
    
                father[j] = i;
                size[i] += size[j];
            }
        }
    }
    bool isConnected(int p, int q)
    {
    
    
        return find(p) == find(q);
    }
};
class Solution
{
    
    
public:
    vector<int> findRedundantConnection(vector<vector<int>> &edges)
    {
    
    
        int n = edges.size();
        UnionFind uf(n + 1);
        // uf.init();
        for (auto &edge : edges)
        {
    
    
            int u = edge[0], v = edge[1];
            if (uf.isConnected(u, v))
                return edge;
            uf.connect(u, v);
        }
        return {
    
    };
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(nlog⁡n)，其中 n 是图中的节点个数。需要遍历图中的 n 条边，对于每条边，需要对两个节点查找祖先，如果两个节点的祖先不同则需要进行合并，需要进行 2 次查找和最多 1 次合并。一共需要进行 2n 次查找和最多 n 次合并，因此总时间复杂度是 O(2nlog⁡n)=O(nlog⁡n)。这里的并查集使用了路径压缩，但是没有使用按秩合并，最坏情况下的时间复杂度是 O(nlog⁡n)，平均情况下的时间复杂度依然是 O(nα(n))，其中 α 为阿克曼函数的反函数，α(n) 可以认为是一个很小的常数。

空间复杂度：O(n)，其中 n 是图中的节点个数。