class unionFind {
public:
    unionFind(int n): id(n), sz(n, 1) {
        iota(id.begin(), id.end(), 0);
    }

    void unionSize(const int& u, const int& v) {
        const int x = find(u);
        const int y = find(v);

        if(x == y) {
            return;
        }

        if(sz[x] < sz[y]) {
            sz[y] += sz[x];
            id[x] = y;
        } else {
            sz[x] += sz[y];
            id[y] = x;
        }
    }

    int find(const int &u) {
        return id[u] == u? u: id[u] = find(id[u]);
    }

private:
    vector<int> id;
    vector<int> sz;
};

class Solution {
public:
    vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
        int n = accounts.size();
        vector<vector<string>> ans;
        
        // {email: index}
        unordered_map<string, int> mailtoIndex;
        // {index: {emails}}
        unordered_map<int, set<string>> indextoMails;

        unionFind uf(n);

        for(int i = 0; i < n; ++i) {
            const string& name = accounts[i][0];
            for(int j = 1; j < accounts[i].size(); ++j) {
                const string& email = accounts[i][j];
                const auto& it = mailtoIndex.find(email);
                if(it == mailtoIndex.end()) {
                    mailtoIndex[email] = i;
                } else {
                    uf.unionSize(i, it->second);
                }
            }
        }

        for(const auto& [email, index]: mailtoIndex) {
            indextoMails[uf.find(index)].insert(email);
        }

        for(const auto& [index, email]: indextoMails) {
            const string& name = accounts[index][0];
            vector<string> row{name};
            row.insert(row.end(), email.begin(), email.end());
            ans.push_back(row);
        }

        return ans;
    }
};