no message

Author: wuduhren

problems/cheapest-flights-within-k-stops.py

@@ -66,3 +66,36 @@ def findCheapestPrice(self, n, flights, src, dst, K):
 
 		return min_price if min_price!=float('inf') else -1
 
+
+"""
+Standard Dijkstra, except this time instead of only explore the ones with least price
+We also need to explore the ones with less steps. So add stepFromSrc to check.
+
+Time: O(ELogE), since there will be at most E edges that get pushed into the heap.
+Space: O(E)
+"""
+class Solution(object):
+    def findCheapestPrice(self, n, flights, src, dst, K):
+        priceFromSrc = {}
+        stepFromSrc = {}
+        h = [(0, 0, src)]
+        G = collections.defaultdict(list)
+        
+        #build graph
+        for s, d, p in flights:
+            G[s].append((d, p))
+        
+        #dijkstra
+        while h:
+            price, k, node = heapq.heappop(h)
+            
+            if node==dst: return price
+            if k>K: continue
+            
+            for nei, price2 in G[node]:
+                if nei not in priceFromSrc or price+price2<=priceFromSrc[nei] or k<stepFromSrc[nei]:
+                    priceFromSrc[nei] = price+price2
+                    stepFromSrc[nei] = k
+                    heapq.heappush(h, (price+price2, k+1, nei))
+                    
+        return -1

problems/maximum-average-subtree.py

@@ -0,0 +1,25 @@
+"""
+Recursivly get the average and count of each node.
+Update the self.ans before returning.
+
+Time: O(N), N is the number of nodes.
+Space: O(LogN) for the recursive stack, since the tree hight is LogN if the tree is balanced.
+"""
+class Solution(object):
+    def __init__(self):
+        self.ans = float('-inf')
+        
+    def maximumAverageSubtree(self, root):
+        def getAVGAndCount(node):
+            if not node: return 0, 0
+            leftAvg, leftCount = getAVGAndCount(node.left)
+            rightAvg, rightCount = getAVGAndCount(node.right)
+            
+            count = leftCount+rightCount+1
+            avg = (leftAvg*leftCount + rightAvg*rightCount + node.val)/float(count)
+            
+            self.ans = max(self.ans, avg)
+            return avg, count
+        
+        getAVGAndCount(root)
+        return self.ans

problems/minimum-swaps-to-group-all-1s-together.py

@@ -0,0 +1,30 @@
+"""
+We know that, after swapping, the length of the continuous 1 will be equal to number of 1 in the data. Let's call it `L`.
+So what we need to do is sliding window with length L and see what is the max 1 count within the window.
+The window with max 1 count will need to do minimal swap.
+"""
+class Solution(object):
+    def minSwaps(self, data):
+        L = 0 #sliding window length
+        #initialize L
+        for num in data:
+            if num==1: L += 1
+        
+
+        count = 0 #count of 1 within the sliding window
+        maxCount = 0 #max count of 1 within the sliding window
+
+        #initialize the count from data[0] to data[L-1]
+        for i in xrange(L):
+            if data[i]==1: count += 1
+        maxCount = count
+
+        #slide the window
+        for i in xrange(1, len(data)):
+            j = i+L-1 #end index of the sliding window
+            if j>=len(data): break
+            if data[j]==1: count += 1
+            if data[i-1]==1: count -= 1
+            maxCount = max(maxCount, count)
+        
+        return L-maxCount

problems/shortest-path-to-get-food.py

@@ -0,0 +1,29 @@
+class Solution(object):
+    def getFood(self, grid):
+        q = collections.deque()
+        visited = set()
+        
+        for i in xrange(len(grid)):
+            for j in xrange(len(grid[0])):
+                if grid[i][j]=='*':
+                    q.append((i, j, 0))
+                    break
+        while q:
+            i, j, steps = q.popleft()
+            
+            if not 0<=i<len(grid): continue
+            if not 0<=j<len(grid[0]): continue
+            if (i, j) in visited: continue
+            visited.add((i, j))
+            
+            if grid[i][j]=='#':
+                return steps
+            elif grid[i][j]=='X':
+                continue
+            elif grid[i][j]=='O' or grid[i][j]=='*':
+                q.append((i+1, j, steps+1))
+                q.append((i-1, j, steps+1))
+                q.append((i, j+1, steps+1))
+                q.append((i, j-1, steps+1))
+        
+        return -1