[Leetcode] Union Find

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