[Leetcode] Union Find

Posted 2022-12-03 stary_yan

[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;
  
;

Time complexity: O(n^2)