1106-review-morning

017. Letter Combinations of a Phone Number.py

@@ -31,15 +31,15 @@ def letterCombinations(self, digits):
         self.dfs(res, '',dic,digits,0)
         return res
 
-    def dfs(self, res, temp, dic,digits,num):
-        if num == len(digits):
+    def dfs(self, res, temp, dic,digits,index):
+        if index == len(digits):
             res.append(temp)
             return
 
         # focus on !
-        # digits[num] -> 2: generate a,b,c
-        for letter in dic[digits[num]]:
-            self.dfs(res, temp+letter, dic, digits, num+1)
+        # digits[index] -> 2: generate a,b,c
+        for letter in dic[digits[index]]:
+            self.dfs(res, temp+letter, dic, digits, index+1)
 
 
 

078. Subsets.py

@@ -26,6 +26,7 @@ def subsets(self, nums):
         res = []
         self.backtracking(nums, [], res, 0)
         return res
+
     def backtracking(self, nums, temp, res, start):
         res.append(list(temp))
         for i in range(start,len(nums)):

207. Course Schedule.py

@@ -57,4 +57,25 @@ def canFinish(self, numCourses, prerequisites):
         if outdegree:
             return False
         return True
+
+    def canFinish(self, n, pres):
+
+        oud = [[] for _ in range(n)]  # indegree
+        ind = [0] * n  # outdegree
+        for succ,pre in pres:
+            ind[succ] += 1
+            oud[pre].append(succ)
+        dq = []
+        for i in range(n):
+            if ind[i] == 0:
+                dq.append(i)
+        count = 0
+        while dq:
+            pre_course = dq.pop(0)
+            count += 1
+            for succ in oud[pre_course]:
+                ind[succ] -= 1
+                if ind[succ] == 0:
+                    dq.append(succ)
+        return count == n
 

286. Walls and Gates.py

@@ -0,0 +1,42 @@
+# You are given a m x n 2D grid initialized with these three possible values.
+
+# -1 - A wall or an obstacle.
+# 0 - A gate.
+# INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647.
+# Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF.
+
+# For example, given the 2D grid:
+# INF  -1  0  INF
+# INF INF INF  -1
+# INF  -1 INF  -1
+#   0  -1 INF INF
+# After running your function, the 2D grid should be:
+#   3  -1   0   1
+#   2   2   1  -1
+#   1  -1   2  -1
+#   0  -1   3   4
+class Solution(object):
+    def wallsAndGates(self, rooms):
+        """
+        :type rooms: List[List[int]]
+        :rtype: void Do not return anything, modify rooms in-place instead.
+        """
+        # init
+        queue = []
+        for row in range(len(rooms)):
+            for col in range(len(rooms[0])):
+                if rooms[row][col] == 0:
+                    queue.append((row,col))
+        direction = [(1,0),(0,1),(-1,0),(0,-1)]
+        while queue:
+            i,j = queue.pop(0)
+            for x,y in direction:
+                row = i + x
+                col = j + y
+                if 0 <= row < len(rooms) and 0 <= col < len(rooms[0]) and rooms[row][col] == 2147483647:
+                    rooms[row][col] = rooms[i][j] + 1
+                    queue.append((row, col))
+                #print rooms
+
+
+

README.md

@@ -2,9 +2,10 @@
 
 ## Freq
 
-[x] Three sum without sorted
-[x] Task Scheduler
-[] 301 remove invalid parenthesis
-[] 17 letter combination of phone
-[x] Sort the numbers based on categories -- 075 follow up
+[x] Three sum without sorted  
+[x] Task Scheduler 
+[] 301 remove invalid parenthesis  
+[] 17 letter combination of phone  
+[x] Sort the numbers based on categories -- 075 follow up 
+[x] Binary Search templete  
 

binarysearch.py

@@ -0,0 +1,23 @@
+a = [1,2,3,4,5,5,5,5,5,5,5,6]
+#a= [1,2,2,4,5,5]
+target = 5
+l = 0
+r = len(a) - 1
+while l +1 < r:
+    mid = (l+r)/2
+    if a[mid] < target:
+        l = mid 
+    else:
+        r = mid 
+print l if a[l] == target else r
+
+
+l = 0
+r = len(a) -1
+while l +1 < r:
+    mid = (l+r)/2
+    if a[mid] <= target:
+        l = mid 
+    else:
+        r = mid 
+print r if a[r] == target else l

shortest distance in 2D array.py

@@ -0,0 +1,40 @@
+class Solution(object):
+    def isvalid(self, row, col,rooms):
+        if 0 <= row < len(rooms) and 0 <= col < len(rooms[0]) and rooms[row][col] == 1:
+            return True
+
+
+    def wallsAndGates(self, rooms,start, end):
+        """
+        O(mn)
+        :type rooms: List[List[int]]
+        :rtype: void Do not return anything, modify rooms in-place instead.
+        """
+        # init
+        queue = []
+        queue.append([start[0], start[1], 0, ""])
+
+
+        visited = [[False for row in range(len(rooms))]for col in range(len(rooms[0]))]
+
+        direction = [(1,0),(0,1),(-1,0),(0,-1)]
+        res = []
+        dist = 0
+        while queue:
+            i,j,dist,path = queue.pop(0)
+            if i == end[0] and j == end[1]:
+                return str(dist) + ', path: ' + path 
+
+            for x,y in direction:
+                row = i + x
+                col = j + y
+                if self.isvalid(row, col,rooms) and not visited[row][col]:
+                    visited[row][col] = True
+                    queue.append((row,col,dist+1,path + str(x) + '->'+ str(y) + ','))
+
+
+test = [[1,-1,0,1],[1,1,1,-1],[1,-1,1,-1],[1,-1,1,1]]
+start = [0,2]
+end = [3,0]
+m = Solution().wallsAndGates(test,start, end)
+print m