no message

wuduhren · wuduhren · commit a9671e8430d8 · 2022-03-02T18:28:53.000+08:00
diff --git a/README.md b/README.md
@@ -37,7 +37,7 @@ I found it makes sense to solve similar problems together, so that we can recogn
 3. [What should I know from the CLRS 3rd edition book if my aim is to get into Google?](https://www.quora.com/What-should-I-know-from-the-CLRS-3rd-edition-book-if-my-aim-is-to-get-into-Google/answer/Jimmy-Saade)
 
 ## Data Structures and Algorithms for beginners
-If you are new or know nothing about data structures and algorithms, I recommend [this course](<https://classroom.udacity.com/courses/ud513>). This course is taught in Python and design to help you find job and do well in the interview.
+If you are new or know nothing about data structures and algorithms, I recommend [this course](<https://www.udacity.com/course/data-structures-and-algorithms-in-python--ud513>). This course is taught in Python and design to help you find job and do well in the interview.
 
 
 # System Design
diff --git a/problems/accounts-merge.py b/problems/accounts-merge.py
@@ -1,3 +1,22 @@
+"""
+Treat each email as a node.
+Build an adjacency graph. [0]
+
+For every account's data
+First, lets check if the first email is already merged. [1]
+If the first email is already merged to other groups, then other emails will be in another group as well.
+So don't need to check.
+
+Second, do a DFS starting from the first email. Put all the connected nodes into visited. [2]
+And append the sorted(visited) to the ans with name. [3]
+
+Let N be the total number of emails. M be the total number of final groups.
+Build the graph takes O(N).
+For each final groups, we make a DFS to all nodes, taking O(MN).
+Sort the group takes O((N/M)*Log(N/M)) -> O((N/M)*(logN-LogM))
+Time: O(MN)
+Space: O(N)
+"""
 from collections import defaultdict
 
 class Solution(object):
@@ -31,22 +50,85 @@ def accountsMerge(self, accounts):
         
         return ans
 
-"""
-Treat each email as a node.
-Build an adjacency graph. [0]
-
-For every account's data
-First, lets check if the first email is already merged. [1]
-If the first email is already merged to other groups, then other emails will be in another group as well.
-So don't need to check.
 
-Second, do a DFS starting from the first email. Put all the connected nodes into visited. [2]
-And append the sorted(visited) to the ans with name. [3]
+#Union Find
+class Solution(object):
+    def accountsMerge(self, accounts):
+        def find(x):
+            p = parents[x]
+            while p!=parents[p]:
+                p = find(p)
+            parents[x] = p
+            return p
+        
+        def union(x, y):
+            p1, p2 = find(x), find(y)
+            if p1==p2: return
+            parents[p2] = p1
+        
+        parents = {}
+        mailToName = {}
+        
+        for account in accounts:
+            name = account[0]
+            root = account[1]
+            if root not in parents: parents[root] = root
+            root = find(root)
+            mailToName[root] = name
+            
+            for i in xrange(2, len(account)):
+                email = account[i]
+                if email in parents:
+                    union(parents[email], root)
+                    root = find(root)
+                parents[email] = root
+        
+        rootToMails = collections.defaultdict(list)
+        for email in parents:
+            rootToMails[find(email)].append(email)
+        
+        ans = []
+        for root in rootToMails:
+            name = mailToName[root]
+            mails = rootToMails[root]
+            ans.append([name]+sorted(mails))
+        
+        return ans
 
-Let N be the total number of emails. M be the total number of final groups.
-Build the graph takes O(N).
-For each final groups, we make a DFS to all nodes, taking O(MN).
-Sort the group takes O((N/M)*Log(N/M)) -> O((N/M)*(logN-LogM))
-Time: O(MN)
-Space: O(N)
-"""
+#DFS
+class Solution(object):
+    def accountsMerge(self, accounts):
+        
+        #build adjacency list
+        adj = collections.defaultdict(list)
+        for account in accounts:
+            name = account[0]
+            email0 = account[1]
+            for i in xrange(2, len(account)):
+                email = account[i]
+                adj[email0].append(email)
+                adj[email].append(email0)
+        
+        #iterate accounts and dfs each email group
+        ans = []
+        visited = set() #store all the visited email
+        for account in accounts:
+            name = account[0]
+            email0 = account[1]
+            if email0 in visited: continue
+            
+            #dfs
+            group = set() #store the email group related to email0
+            stack = [email0]
+            while stack:
+                email = stack.pop()
+                if email in group or email in visited: continue
+                group.add(email)
+                visited.add(email)
+                for nei in adj[email]:
+                    stack.append(nei)
+            
+            ans.append([name]+sorted(list(group)))
+        
+        return ans
+            
diff --git a/problems/diagonal-traverse.py b/problems/diagonal-traverse.py
@@ -0,0 +1,25 @@
+class Solution(object):
+    def findDiagonalOrder(self, mat):
+        def helper(i, j, reverse):
+            output = []
+            while 0<=i<len(mat) and 0<=j<len(mat[0]):
+                output.append(mat[i][j])
+                i += 1
+                j -= 1
+            return output if not reverse else reversed(output)
+        
+        
+        M = len(mat)
+        N = len(mat[0])
+        ans = []
+        reverse = True
+        
+        for j in xrange(N):
+            ans += helper(0, j, reverse)
+            reverse = not reverse
+        
+        for i in xrange(1, M):
+            ans += helper(i, N-1, reverse)
+            reverse = not reverse
+        
+        return ans
diff --git a/problems/group-shifted-strings.py b/problems/group-shifted-strings.py
@@ -0,0 +1,20 @@
+class Solution(object):
+    def groupStrings(self, strings):
+        def getHash(string):
+            h = ''
+            offset = getNumByChar(string[0])*-1
+            for c in string:
+                h += getCharByNum((getNumByChar(c)+offset) if (getNumByChar(c)+offset)>=0 else 26+(getNumByChar(c)+offset))
+            return h
+        
+        def getNumByChar(letter):
+            return ord(letter) - 97
+
+        def getCharByNum(pos):
+            return chr(pos + 97)
+        
+        groups = collections.defaultdict(list)
+        for string in strings:
+            h = getHash(string)
+            groups[h].append(string)
+        return groups.values()
diff --git a/problems/making-a-large-island.py b/problems/making-a-large-island.py
@@ -1,3 +1,10 @@
+"""
+For each "island" asign them a group id. Also calculate the group's size.
+Iterate all the zeros, update the ans.
+
+Time:O(MN)
+Space: O(MN) in the worst case.
+"""
 class Solution(object):
     def largestIsland(self, grid):
         def isValid(i, j, M, N):
diff --git a/problems/maximum-swap.py b/problems/maximum-swap.py
@@ -0,0 +1,23 @@
+"""
+1. Generate positions. Storing the mapping between number to indices.
+2. Iterate from left, for each n1, find the largest number larger than n1 (searching from 9, 8, 7 to n1+1).
+3. Since we need to find the max output. There might be multiple the same number, we need to find the index of the rightest number.
+4. Remove n1 when it is done. Because right of the n1 should not consider it anymore.
+"""
+class Solution(object):
+    def maximumSwap(self, num):
+        numList = [int(n) for n in str(num)]
+        positions = collections.defaultdict(list)
+        for i, n in enumerate(numList): positions[n].append(i) #[1]
+        
+        i = 0
+        for i, n1 in enumerate(numList): #[2]
+            n1 = numList[i]
+            for n2 in xrange(9, n1, -1): 
+                if n2 in positions and len(positions[n2])>0:
+                    j = positions[n2][-1] #[3]
+                    numList[i], numList[j] = numList[j], numList[i]
+                    return int(''.join([str(n) for n in numList]))
+            positions[n1].pop(0) #[4]
+            
+        return num
diff --git a/problems/valid-number.py b/problems/valid-number.py
@@ -41,4 +41,4 @@ def isOK(s, maxDots):
         elif eCount==1:
             return isOK(s[:ePos], 1) and isOK(s[ePos+1:], 0)
         else:
-            return isOK(s, 1)
+            return isOK(s, 1)
