update 721

fishercoder1534 · fishercoder1534 · commit 0faa5d17789b · 2024-06-09T15:33:22.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_721.java b/src/main/java/com/fishercoder/solutions/_721.java
@@ -66,13 +66,13 @@ public List<List<String>> accountsMerge(List<List<String>> accounts) {
     public static class Solution2 {
         /**
          * credit: https://leetcode.com/articles/accounts-merge/#approach-2-union-find-accepted
-         * DSU stands for Disjoint Set Union: https://en.wikipedia.org/wiki/Disjoint-set_data_structure
+         * DSU stands for Disjoint Set Union: https://en.wikipedia.org/wiki/Disjoint-set_data_structure, a.k.a Union Find data structure.
          * <p>
-         * Time complexity: O(AlogA)
-         * Space complexity: O(A)
+         * Time complexity: O(nlogn)
+         * Space complexity: O(n)
          */
         public List<List<String>> accountsMerge(List<List<String>> accounts) {
-            DSU dsu = new DSU();
+            UnionFind uf = new UnionFind();
             Map<String, String> emailToName = new HashMap<>();
             Map<String, Integer> emailToId = new HashMap<>();
             int id = 0;
@@ -87,28 +87,31 @@ public List<List<String>> accountsMerge(List<List<String>> accounts) {
                     if (!emailToId.containsKey(email)) {
                         emailToId.put(email, id++);
                     }
-                    dsu.union(emailToId.get(account.get(1)), emailToId.get(email));
+                    uf.union(emailToId.get(account.get(1)), emailToId.get(email));
                 }
             }
 
-            Map<Integer, List<String>> ans = new HashMap<>();
+            Map<Integer, List<String>> map = new HashMap<>();
             for (String email : emailToName.keySet()) {
-                int index = dsu.find(emailToId.get(email));
-                ans.computeIfAbsent(index, x -> new ArrayList()).add(email);
+                //find the index of this email first: use this email's ID to find its parent in the Union Find
+                int index = uf.find(emailToId.get(email));
+                map.computeIfAbsent(index, x -> new ArrayList()).add(email);
             }
-            for (List<String> component : ans.values()) {
+            for (List<String> component : map.values()) {
                 Collections.sort(component);
+                //this is to add name to the head of the list
                 component.add(0, emailToName.get(component.get(0)));
             }
-            return new ArrayList<>(ans.values());
+            return new ArrayList<>(map.values());
         }
 
-        class DSU {
+        class UnionFind {
             int[] parent;
+            int size = 10001;
 
-            public DSU() {
-                parent = new int[10001];
-                for (int i = 0; i <= 10000; i++) {
+            public UnionFind() {
+                parent = new int[size];
+                for (int i = 0; i < size; i++) {
                     parent[i] = i;
                 }
             }
@@ -121,7 +124,7 @@ public int find(int x) {
             }
 
             public void union(int x, int y) {
-                parent[find(x)] = find(y);
+                parent[find(x)] = find(y);//can be written as parent[find(y)] = find(x); they are equivalent
             }
         }
     }
diff --git a/src/test/java/com/fishercoder/_721Test.java b/src/test/java/com/fishercoder/_721Test.java
@@ -1,8 +1,8 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._721;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -14,8 +14,8 @@ public class _721Test {
     private static List<List<String>> accounts;
     private static List<List<String>> expected;
 
-    @BeforeClass
-    public static void setup() {
+    @BeforeEach
+    public void setup() {
         solution1 = new _721.Solution1();
         solution2 = new _721.Solution2();
     }

Original file line number	Diff line number	Diff line change
`@@ -66,13 +66,13 @@ public List<List<String>> accountsMerge(List<List<String>> accounts) {`
`66`	`66`	`public static class Solution2 {`
`67`	`67`	`/**`
`68`	`68`	`* credit: https://leetcode.com/articles/accounts-merge/#approach-2-union-find-accepted`
`69`		`- * DSU stands for Disjoint Set Union: https://en.wikipedia.org/wiki/Disjoint-set_data_structure`
	`69`	`+ * DSU stands for Disjoint Set Union: https://en.wikipedia.org/wiki/Disjoint-set_data_structure, a.k.a Union Find data structure.`
`70`	`70`	`* <p>`
`71`		`- * Time complexity: O(AlogA)`
`72`		`- * Space complexity: O(A)`
	`71`	`+ * Time complexity: O(nlogn)`
	`72`	`+ * Space complexity: O(n)`
`73`	`73`	`*/`
`74`	`74`	`public List<List<String>> accountsMerge(List<List<String>> accounts) {`
`75`		`- DSU dsu = new DSU();`
	`75`	`+ UnionFind uf = new UnionFind();`
`76`	`76`	`Map<String, String> emailToName = new HashMap<>();`
`77`	`77`	`Map<String, Integer> emailToId = new HashMap<>();`
`78`	`78`	`int id = 0;`
`@@ -87,28 +87,31 @@ public List<List<String>> accountsMerge(List<List<String>> accounts) {`
`87`	`87`	`if (!emailToId.containsKey(email)) {`
`88`	`88`	`emailToId.put(email, id++);`
`89`	`89`	`}`
`90`		`- dsu.union(emailToId.get(account.get(1)), emailToId.get(email));`
	`90`	`+ uf.union(emailToId.get(account.get(1)), emailToId.get(email));`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`- Map<Integer, List<String>> ans = new HashMap<>();`
	`94`	`+ Map<Integer, List<String>> map = new HashMap<>();`
`95`	`95`	`for (String email : emailToName.keySet()) {`
`96`		`- int index = dsu.find(emailToId.get(email));`
`97`		`- ans.computeIfAbsent(index, x -> new ArrayList()).add(email);`
	`96`	`+ //find the index of this email first: use this email's ID to find its parent in the Union Find`
	`97`	`+ int index = uf.find(emailToId.get(email));`
	`98`	`+ map.computeIfAbsent(index, x -> new ArrayList()).add(email);`
`98`	`99`	`}`
`99`		`- for (List<String> component : ans.values()) {`
	`100`	`+ for (List<String> component : map.values()) {`
`100`	`101`	`Collections.sort(component);`
	`102`	`+ //this is to add name to the head of the list`
`101`	`103`	`component.add(0, emailToName.get(component.get(0)));`
`102`	`104`	`}`
`103`		`- return new ArrayList<>(ans.values());`
	`105`	`+ return new ArrayList<>(map.values());`
`104`	`106`	`}`
`105`	`107`
`106`		`- class DSU {`
	`108`	`+ class UnionFind {`
`107`	`109`	`int[] parent;`
	`110`	`+ int size = 10001;`
`108`	`111`
`109`		`- public DSU() {`
`110`		`- parent = new int[10001];`
`111`		`- for (int i = 0; i <= 10000; i++) {`
	`112`	`+ public UnionFind() {`
	`113`	`+ parent = new int[size];`
	`114`	`+ for (int i = 0; i < size; i++) {`
`112`	`115`	`parent[i] = i;`
`113`	`116`	`}`
`114`	`117`	`}`
`@@ -121,7 +124,7 @@ public int find(int x) {`
`121`	`124`	`}`
`122`	`125`
`123`	`126`	`public void union(int x, int y) {`
`124`		`- parent[find(x)] = find(y);`
	`127`	`+ parent[find(x)] = find(y);//can be written as parent[find(y)] = find(x); they are equivalent`
`125`	`128`	`}`
`126`	`129`	`}`
`127`	`130`	`}`