no message

Author: wuduhren

problems/campus-bikes-ii.py

@@ -0,0 +1,35 @@
+"""
+state[i] := ith bike has been selected.
+For example, there are M bikes, 0000, 0100, 0110, 1111.....
+
+Time: O(ELogE)
+Space: O(E)
+"""
+class Solution(object):
+    def assignBikes(self, workers, bikes):
+        M = len(bikes)
+        N = len(workers)
+        costs = [[0]*N for _ in xrange(M)]
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                costs[i][j] = abs(workers[j][0]-bikes[i][0])+abs(workers[j][1]-bikes[i][1])
+        
+        pq = [(0, '0'*M)]
+        visited = set()
+        while pq:
+            cost, state = heapq.heappop(pq)
+            if state in visited: continue
+            visited.add(state)
+            
+            j = state.count('1') #j users have selected bikes
+            if j>=N: return cost
+            
+            for i in xrange(M):
+                if state[i]=='1': continue
+                
+                nextState = state[:i] + '1' + state[i+1:]
+                if nextState in visited: continue
+                heapq.heappush(pq, (cost+costs[i][j], nextState))
+        
+        return float('inf')

problems/construct-binary-tree-from-inorder-and-postorder-traversal.py

@@ -68,4 +68,35 @@ def helper(i, j, k, l):
 
         index = {} #the index of inorder
         for i, n in enumerate(inorder): index[n] = i
-        return helper(0, len(inorder), 0, len(postorder))
+        return helper(0, len(inorder), 0, len(postorder))
+
+
+
+
+
+"""
+Inorder: [LEFT]root[RIGHT]
+Postorder: [LEFT][RIGHT]root
+As you can see, rootVal is the last val in postorder.
+
+i and j is the range of the inorder
+k and l is the range of the postorder
+Get the root
+Also recursively use the same method to get the left and right node, but this time we change the inorder and postorder.
+"""
+class Solution(object):
+    def buildTree(self, inorder, postorder):
+        def helper(i, j, k, l):
+            if i>j or k>l: return None
+            rootVal = postorder[l]
+            root = TreeNode(rootVal)
+            r = inorderIndex[rootVal]
+            leftLength = r-i
+            rightLength = j-r
+            root.left = helper(i, r-1, k, k+leftLength-1)
+            root.right = helper(r+1, j, k+leftLength, k+leftLength+rightLength-1)
+            return root
+            
+        inorderIndex = {}
+        for i, n in enumerate(inorder): inorderIndex[n] = i
+        return helper(0, len(inorder)-1, 0, len(postorder)-1)

problems/flip-binary-tree-to-match-preorder-traversal.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def flipMatchVoyage(self, root, voyage):
+        def helper(node):
+            if not node: return
+            if node.val!=voyage[self.i]:
+                self.valid = False
+                return
+            
+            self.i += 1
+            if node.left and node.left.val!=voyage[self.i]:
+                self.ans.append(node.val)
+                helper(node.right)
+                helper(node.left)
+                
+            else:
+                helper(node.left)
+                helper(node.right)
+        
+        self.ans = []
+        self.i = 0
+        self.valid = True
+        helper(root)
+        return self.ans if self.valid else [-1]

problems/kth-largest-element-in-an-array.py

@@ -63,4 +63,34 @@ def partition(A, l, r, p):
 
         k = len(nums)-k #redefine the problem to find the kth nums when sorted
         sortRange(nums, 0, len(nums)-1)
-        return nums[k]
+        return nums[k]
+
+
+#Quick Select
+class Solution(object):
+    def findKthLargest(self, nums, K):
+        def quickSelect(A, s, e, K):
+            pivot = A[(s+e)/2]
+            i = s
+            t = s
+            j = e
+            
+            while t<=j:
+                if A[t]<pivot:
+                    A[i], A[t] = A[t], A[i]
+                    i += 1
+                    t += 1
+                elif A[t]==pivot:
+                    t += 1
+                else:
+                    A[t], A[j] = A[j], A[t]
+                    j -= 1
+            
+            if e-j>=K:
+                return quickSelect(A, j+1, e, K)
+            elif e-i+1>=K:
+                return pivot
+            else:
+                return quickSelect(A, s, i-1, K-(e-(i-1)))
+            
+        return quickSelect(nums, 0, len(nums)-1, K)

problems/maximum-compatibility-score-sum.py

@@ -0,0 +1,44 @@
+"""
+Time: O(ELogE), E is the edge of the graph.
+Note that state[i] means if the ith student is matched or not. (for example M=4, 0000, 0010, 0111, 1111...)
+2^M is the number of states. So in this case E will be 2^M x M.
+
+Space: O(2^M)
+"""
+class Solution(object):
+    def maxCompatibilitySum(self, students, mentors):
+        M = len(students)
+        N = len(students[0])
+
+        #initialize reverseScores
+        reverseScores = [[0]*M for _ in xrange(M)]
+        for i in xrange(M):
+            for j in xrange(M):
+                reverseScore = 0
+                for k in xrange(N):
+                    if students[i][k]!=mentors[j][k]:
+                        reverseScore += 1
+                reverseScores[i][j] = reverseScore
+        
+        #Dijkstra
+        startState = '0'*M
+        endState = '1'*M
+        visited = set()
+        pq = [(0, startState)]
+        
+        while pq:
+            cost, state = heapq.heappop(pq)
+            if state in visited: continue
+            visited.add(state)
+            
+            if state==endState: return M*N-cost
+            
+            j = state.count('1')
+            for i in xrange(M):
+                if state[i]=='1': continue
+                
+                nextState = state[:i]+'1'+state[i+1:]
+                if nextState in visited: continue
+                heapq.heappush(pq, (cost+reverseScores[i][j], nextState))
+        
+        return -1

problems/minimum-cost-to-make-at-least-one-valid-path-in-a-grid.py

@@ -0,0 +1,32 @@
+class Solution(object):
+    def minCost(self, grid):
+        pq = [(0, False, 0, 0, 0)]
+        visited = set()
+        M = len(grid)
+        N = len(grid[0])
+        
+        while pq:
+            cost, modified, direction, x, y = heapq.heappop(pq)
+            if x<0 or x>=M or y<0 or y>=N: continue
+            if (direction, x, y) in visited: continue
+            visited.add((direction, x, y))
+            
+            if x==M-1 and y==N-1: return cost
+            
+            if direction==0: direction = grid[x][y]
+
+            if direction==1:
+                heapq.heappush(pq, (cost, False, 0, x, y+1))
+            elif direction==2:
+                heapq.heappush(pq, (cost, False, 0, x, y-1))
+            elif direction==3:
+                heapq.heappush(pq, (cost, False, 0, x+1, y))
+            elif direction==4:
+                heapq.heappush(pq, (cost, False, 0, x-1, y))
+        
+            if not modified:    
+                for d in [1,2,3,4]:
+                    if d==grid[x][y]: continue
+                    heapq.heappush(pq, (cost+1, True, d, x, y))
+                            
+        return float('inf')

problems/minimum-xor-sum-of-two-arrays.py

@@ -0,0 +1,24 @@
+"""
+state[i] := nums1[i] has been matched.
+"""
+class Solution(object):
+    def minimumXORSum(self, nums1, nums2):
+        N = len(nums1)
+        
+        pq = [(0, '0'*N)]
+        visited = set()
+        while pq:
+            s, state = heapq.heappop(pq)
+            if state in visited: continue
+            visited.add(state)
+            
+            j = state.count('1')
+            if j==N: return s
+            
+            for i in xrange(N):
+                if state[i]=='1': continue
+                nextState = state[:i]+'1'+state[i+1:]
+                if nextState in visited: continue
+                heapq.heappush(pq, ((s+(nums1[i]^nums2[j-1]), nextState)))
+        
+        return float('inf')

problems/network-delay-time.py

@@ -118,12 +118,96 @@ def networkDelayTime(self, times, n, k):
 
 
 
+"""
+Dijkstra BFS+Priority Queue Implementation
+Time: O(ELogE), E is the edges count in the graph.
+"""
+class Solution(object):
+    def networkDelayTime(self, times, N, K):
+        ans = -1 #max time from K to any
+        visited = set()
+        pq = [(0, K)] #[(node's distance to K, node)]
+        
+        #construct adjacency list
+        adj = collections.defaultdict(list)
+        for u, v, w in times:
+            adj[u].append((w, v))
+            
+        while pq:
+            dis, node = heapq.heappop(pq)
+            if node in visited: continue
+            visited.add(node)
+            
+            ans = max(ans, dis)
+            
+            for d2, nei in adj[node]:
+                heapq.heappush(pq, (d2+dis, nei))
+        
+        return ans if len(visited)==N else -1
 
 
 
+"""
+Dijkstra Normal Implementation
+Time: O(N^2), N is the nodes count in the graph.
+"""
+class Solution(object):
+    def networkDelayTime(self, times, N, K):
+        #construct dis. dis[n] := node n distance to K
+        dis = {}
+        for n in xrange(1, N+1):
+            dis[n] = float('inf')
+        dis[K] = 0
+        
+        visited = set()
+        
+        #construct adjacency list
+        adj = collections.defaultdict(list)
+        for u, v, w in times:
+            adj[u].append((w, v))
+        
 
+        while len(visited)<N:
+            #find the nearest node to K, lets call it minDisNode
+            minDisNode = None
+            minDis = float('inf')
+            
+            for n in xrange(1, N+1):
+                if n not in visited and dis[n]<minDis:
+                    minDisNode = n
+                    minDis = dis[n]
+            
+            #update minDisNode neighbor's distance to K    
+            if minDis==float('inf'): break
+            for d2, nei in adj[minDisNode]:
+                dis[nei] = min(dis[nei], d2+minDis)
+            
+            #store the node we alreay determined the distance to K in visited
+            visited.add(minDisNode)
+        
+        return max(dis.values()) if len(visited)==N else -1
 
 
-
-
-
+"""
+Floyd
+Time: O(N^3), N is the nodes count in the graph.
+Note that Floyed can calculate the shortest distance between any two nodes.
+Also, it can handle negative values on the edge.
+"""
+class Solution(object):
+    def networkDelayTime(self, times, N, K):
+        #dp[i-1][j-1] := distance from i to j
+        dp = [[float('inf') for i in xrange(1, N+1)] for j in xrange(1, N+1)]
+        
+        for i in xrange(1, N+1):
+            dp[i-1][i-1] = 0
+        for u, v, w in times:
+            dp[u-1][v-1] = w
+        
+        for k in xrange(1, N+1):
+            for i in xrange(1, N+1):
+                for j in xrange(1, N+1):
+                    dp[i-1][j-1] = min(dp[i-1][j-1], dp[i-1][k-1]+dp[k-1][j-1])
+        
+        ans = max(dp[K-1])
+        return ans if ans!=float('inf') else -1

problems/number-of-ways-to-arrive-at-destination.py

@@ -0,0 +1,33 @@
+class Solution(object):
+    def countPaths(self, n, roads):
+        def countWaysToReach(node):
+            if node==0: return 1
+            if node in history: return history[node]
+            c = 0
+            for nei, t in adj[node]:
+                if nei in times and times[nei]+t==times[node]:
+                    c += countWaysToReach(nei)
+            history[node] = c
+            return c
+        
+        history = {} #cache for countWaysToReach()
+        times = {} #min times to reach node n-1
+        pq = [(0, 0)]
+        
+        adj = collections.defaultdict(list)
+        for u, v, t in roads:
+            adj[u].append((v, t))
+            adj[v].append((u, t))
+        
+        while pq:
+            t, node = heapq.heappop(pq)
+            if node in times: continue
+            times[node] = t
+            
+            if node==n-1: break
+            
+            for nei, t2 in adj[node]:
+                if nei in times: continue
+                heapq.heappush(pq, (t+t2, nei))
+        
+        return countWaysToReach(n-1)%(10**9 + 7)