feat: 🎸 leetcode 721

Author: dandedotdev

src/0001-1000/721/accountsMerge.ts

@@ -0,0 +1,67 @@
+// <Recursion, DFS, HashTable>
+// Time: O(nlogn)
+// Space: O(n)
+
+function dfs(
+    accounts: string[][],
+    emailSet: Set<string>,
+    emailToIndexes: Map<string, number[]>,
+    visited: boolean[],
+    index: number,
+) {
+    visited[index] = true
+
+    for (let i = 1; i < accounts[index].length; ++i) {
+        const email = accounts[index][i]
+
+        if (emailSet.has(email)) {
+            continue
+        }
+
+        emailSet.add(email)
+
+        for (const j of emailToIndexes.get(email)!) {
+            if (!visited[j]) {
+                dfs(accounts, emailSet, emailToIndexes, visited, j)
+            }
+        }
+    }
+}
+
+function accountsMerge(accounts: string[][]): string[][] {
+    // edge cases
+    if (!accounts.length) {
+        return []
+    }
+
+    const n = accounts.length
+    const emailToIndexes = new Map<string, number[]>() // Map<email, index[]>
+
+    for (let i = 0; i < n; ++i) {
+        for (let j = 1; j < accounts[i].length; ++j) {
+            const email = accounts[i][j]
+
+            if (!emailToIndexes.has(email)) {
+                emailToIndexes.set(email, [])
+            }
+
+            emailToIndexes.get(email)!.push(i)
+        }
+    }
+
+    const visited: boolean[] = new Array(n)
+    const emailSet = new Set<string>() // Set<email>
+    const mergedAccounts: string[][] = []
+
+    for (let i = 0; i < n; ++i) {
+        if (!visited[i]) {
+            emailSet.clear()
+            dfs(accounts, emailSet, emailToIndexes, visited, i)
+            mergedAccounts.push([accounts[i][0], ...Array.from(emailSet).sort()])
+        }
+    }
+
+    return mergedAccounts
+}
+
+export { accountsMerge }

src/0001-1000/721/accountsMerge2.ts

@@ -0,0 +1,53 @@
+import { UnionFindWithRank } from 'classes/UnionFindWithRank'
+
+// <Union Find, HashTable>
+// Time: O(nlogn * α(n)), α() is the inverse Ackermann function
+// Space: O(n)
+
+function accountsMerge(accounts: string[][]): string[][] {
+    // edge cases
+    if (!accounts.length) {
+        return []
+    }
+
+    const n = accounts.length
+    const uf = new UnionFindWithRank(n)
+    const emailToIndex = new Map<string, number>() // Map<email, index>
+
+    for (let i = 0; i < n; ++i) {
+        for (let j = 1; j < accounts[i].length; ++j) {
+            const email = accounts[i][j]
+
+            if (!emailToIndex.has(email)) {
+                emailToIndex.set(email, i)
+                continue
+            }
+
+            uf.union(i, emailToIndex.get(email)!)
+        }
+    }
+
+    const indexToEmails = new Map<number, Set<string>>() // Map<index, Set<email>>
+
+    for (let i = 0; i < n; ++i) {
+        const root = uf.find(i)
+
+        if (!indexToEmails.has(root)) {
+            indexToEmails.set(root, new Set<string>())
+        }
+
+        for (let j = 1; j < accounts[i].length; ++j) {
+            indexToEmails.get(root)!.add(accounts[i][j])
+        }
+    }
+
+    const mergedAccounts: string[][] = []
+
+    for (const [index, emails] of indexToEmails) {
+        mergedAccounts.push([accounts[index][0], ...Array.from(emails).sort()])
+    }
+
+    return mergedAccounts
+}
+
+export { accountsMerge }