[Leetcode] Union Find_leetcode union find-优快云博客

本文通过两个具体的LeetCode题目，展示了如何利用并查集算法解决实际问题。首先介绍的是寻找最长连续序列的问题，其次是如何合并账户中的电子邮件地址。通过对这两个问题的解析，读者可以更好地理解并查集的应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

[Leetcode] Union Find

This week, I will solve two problems in the section union find. As we all know, union find is a kind of useful algorithm to find the circle in a directed graph, so it is necessary for us to know how to use it in different situations.

128. Longest Consecutive Sequence

Longest Consecutive Sequence

Analysis

It is easy to understand the meaning of the question. What we need to do is the find the longest consecutive sequence, so we have to sort the array at first, but the time complexity is O(nlogn) and we have to take care of reduplicate nums. The easy way to sort the array and ignore the reduplicate nums is by using set. And then it is easy to think about how to count the max length of consecutive sequence.

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
      set<int> records;
      for (auto each : nums) {
        records.insert(each);
      }

      int tmpLen = 0;
      int maxLen = 0;
      int pre = 0;
      bool begin = true;
      for (auto each : records) {
          if (begin) {
            tmpLen++;
            begin = false;
            pre = each;
          } else {
            if (each == pre + 1) {
              pre = each;
              tmpLen++;
            } else {
              maxLen = max(maxLen, tmpLen);
              tmpLen = 1;
              pre = each;
            }
          }
          maxLen = max(maxLen, tmpLen);
      }
      return maxLen;
    }
};

Time complexity: O(nlogn).
Actually, I don’t know why it should or need to use union find.

721. Accounts Merge

Accounts Merge

In this question, we have to use union find. We have to define three maps:

name	type	description
owners	map

class Solution {
private:
  string find(string str, map<string, string>& tables) {
    return tables[str] == str ? str : find(tables[str], tables);
  }
public:
  vector<vector<string>> accountsMerge(vector<vector<string>>& acts) {
    map<string, string> owners;
    map<string, string> parents;
    map<string, set<string>> unions;
    for (int i = 0; i < acts.size(); i++) {
      for (int j = 1; j < acts[i].size(); j++) {
        parents[acts[i][j]] = acts[i][j];
        owners[acts[i][j]] = acts[i][0];
      }
    }

    for (int i = 0; i < acts.size(); i++) {
      string parent = find(acts[i][1], parents);
      for (int j = 2; j < acts[i].size(); j++) {
        parents[find(acts[i][j], parents)] = parent;
      }
    }

    for (int i = 0; i < acts.size(); i++) {
      for (int j = 1; j < acts[i].size(); j++) {
        unions[find(acts[i][j], parents)].insert(acts[i][j]);
      }
    }

    vector<vector<string>> res;
    for (auto each : unions) {
      vector<string> tmp(each.second.begin(), each.second.end());
      tmp.insert(tmp.begin(), owners[each.first]);
      res.push_back(tmp);
    }
    return res;
  }
};