339

Author: RealHacker

269_alien_dictionary/dictionary.py

@@ -18,14 +18,37 @@ def alienOrder(self, words):
                 if word1[j]!=word2[j]:
                     self.add_to_mat(word1[j], word2[j])
                     break
-                
+        
+        # the alphabet only includes the chars that appear in words        
         alphabet = set()
         for word in words:
-            alphabet.add([c for c in word])
+            for c in word:
+                alphabet.add(c)
 
         # toplogical sort
+        degree_in = {}
+        for char in alphabet:
+            j = ord(char)-ord('a')
+            degree_in[char]=sum([self.matrix[i][j] for i in range(26)])
 
-    
+        result = ""
+        while True:
+            hasZeroDegree=False
+            for c in degree_in:
+                if degree_in[c]==0:
+                    hasZeroDegree = True
+                    degree_in[c]=-1 # skip in the following checks
+                    result += c
+                    for k in range(26):
+                        if self.matrix[ord(c)-ord('a')][k]>0:
+                            degree_in[chr(ord('a')+k)]-=1
+                    # print c
+                    # print degree_in
+            if not hasZeroDegree:
+                if len(result)==len(alphabet):
+                    return result
+                return ""
+            
     def add_to_mat(self, c1, c2):
         i1 = ord(c1)-ord('a')
         i2 = ord(c2)-ord('a')

269_alien_dictionary/problem.txt

@@ -0,0 +1,18 @@
+There is a new alien language which uses the latin alphabet. However, the order among letters are unknown to you. You receive a list of words from the dictionary, where words are sorted lexicographically by the rules of this new language. Derive the order of letters in this language.
+
+For example,
+Given the following words in dictionary,
+
+[
+  "wrt",
+  "wrf",
+  "er",
+  "ett",
+  "rftt"
+]
+The correct order is: "wertf".
+
+Note:
+You may assume all letters are in lowercase.
+If the order is invalid, return an empty string.
+There may be multiple valid order of letters, return any one of them is fine.

276_paint_fence/paint.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def numWays(self, n, k):
+        """
+        :type n: int
+        :type k: int
+        :rtype: int
+        """
+        self.memo = {}
+        return self.recurse(n, k)
+        
+    def recurse(self, n, k):
+        if n==0: return 0
+        if n==1: return k
+        if n==2: return k*k
+        if n not in self.memo:
+            self.memo[n] = self.recurse(n-1,k)*(k-1)+self.recurse(n-2,k)*(k-1)
+        return self.memo[n]
+        
+        
+        
+        
+        

276_paint_fence/problem.txt

@@ -0,0 +1,13 @@
+There is a fence with n posts, each post can be painted with one of the k colors.
+
+You have to paint all the posts such that no more than two adjacent fence posts have the same color.
+
+Return the total number of ways you can paint the fence.
+
+Note:
+n and k are non-negative integers.
+
+Hide Company Tags Google
+Show Tags
+Show Similar Problems
+

302_smallest_rectangle_enclosing_pixels/problem.txt

@@ -0,0 +1,40 @@
+class Solution(object):
+    def minArea(self, image, x, y):
+        """
+        :type image: List[List[str]]
+        :type x: int
+        :type y: int
+        :rtype: int
+        """
+        if not image:
+            return 0
+        # BFS from x, y to find the boundaries
+        xl = len(image)
+        yl = len(image[0])
+        minx, maxx = x, x
+        miny, maxy = y, y
+        
+        visited = set((x, y))
+        q = [(x,y)]
+        
+        # Loop for BFS 
+        while q:
+            xx, yy = q.pop(0)
+            directions = [(1,0), (-1,0), (0, 1), (0, -1)]
+            for dx, dy in directions:
+                # print xx+dx, yy+dy
+                if (0<=xx+dx<xl and 0<=yy+dy<yl and image[xx+dx][yy+dy]=='1' 
+                    and (xx+dx, yy+dy) not in visited):
+                    q.append((xx+dx, yy+dy))
+                    visited.add((xx+dx, yy+dy))
+                    minx = min(minx, xx+dx)
+                    maxx = max(maxx, xx+dx)
+                    miny = min(miny, yy+dy)
+                    maxy = max(maxy, yy+dy)
+        #     print q
+        # print minx, maxx, miny, maxy
+        return (maxx-minx+1)*(maxy-miny+1)
+        
+                    
+                    
+        

302_smallest_rectangle_enclosing_pixels/smallest.py

@@ -0,0 +1,40 @@
+class Solution(object):
+    def minArea(self, image, x, y):
+        """
+        :type image: List[List[str]]
+        :type x: int
+        :type y: int
+        :rtype: int
+        """
+        if not image:
+            return 0
+        # BFS from x, y to find the boundaries
+        xl = len(image)
+        yl = len(image[0])
+        minx, maxx = x, x
+        miny, maxy = y, y
+        
+        visited = set((x, y))
+        q = [(x,y)]
+        
+        # Loop for BFS 
+        while q:
+            xx, yy = q.pop(0)
+            directions = [(1,0), (-1,0), (0, 1), (0, -1)]
+            for dx, dy in directions:
+                # print xx+dx, yy+dy
+                if (0<=xx+dx<xl and 0<=yy+dy<yl and image[xx+dx][yy+dy]=='1' 
+                    and (xx+dx, yy+dy) not in visited):
+                    q.append((xx+dx, yy+dy))
+                    visited.add((xx+dx, yy+dy))
+                    minx = min(minx, xx+dx)
+                    maxx = max(maxx, xx+dx)
+                    miny = min(miny, yy+dy)
+                    maxy = max(maxy, yy+dy)
+        #     print q
+        # print minx, maxx, miny, maxy
+        return (maxx-minx+1)*(maxy-miny+1)
+        
+                    
+                    
+        

302_smallest_rectangle_enclosing_pixels/smallest_binary_search.py

@@ -0,0 +1,58 @@
+import bisect
+class Solution(object):
+    def minArea(self, image, x, y):
+        """
+        :type image: List[List[str]]
+        :type x: int
+        :type y: int
+        :rtype: int
+        """
+        if not image:
+            return 0
+        # BFS from x, y to find the boundaries
+        xl = len(image)
+        yl = len(image[0])
+        minx, maxx = x, x+1
+        miny, maxy = y, y+1
+        
+        lo, hi = 0, x
+        while lo<hi:
+            mid = (lo+hi)/2
+            if any([c=='1' for c in image[mid]]):
+                hi = mid
+            else:
+                lo = mid+1
+        minx = hi
+        
+        lo, hi = x, xl
+        while lo<hi:
+            mid = (lo+hi)/2
+            if any([c=='1' for c in image[mid]]):
+                lo = mid+1
+            else:
+                hi = mid
+        maxx = hi
+        print minx, maxx
+        lo, hi = 0, y
+        while lo<hi:
+            mid = (lo+hi)/2
+            if any([image[i][mid]=='1' for i in range(minx, maxx)]):
+                hi = mid
+            else:
+                lo = mid+1
+        miny = hi
+        
+        lo, hi = y, yl
+        while lo<hi:
+            mid = (lo+hi)/2
+            if any([image[i][mid]=='1' for i in range(minx, maxx)]):
+                lo = mid+1
+            else:
+                hi = mid
+        maxy = hi
+        print miny, maxy
+        return (maxx-minx)*(maxy-miny)
+        
+                    
+                    
+        

311_sparse_matrix_multiplication/multiply.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def multiply(self, A, B):
+        """
+        :type A: List[List[int]]
+        :type B: List[List[int]]
+        :rtype: List[List[int]]
+        """
+        if not A or not B: return []
+        ra = len(A)
+        la = len(A[0])
+        rb = len(B)
+        lb = len(B[0])
+        
+        b_status = [any([B[i][j] for i in range(rb)]) for j in range(lb)]
+        result = []
+        for i in range(ra):
+            if not any(A[i]):
+                result.append([0]*lb)
+            else:
+                temp = []
+                for j in range(lb):
+                    if not b_status:
+                        temp.append(0)
+                    else:
+                        temp.append(sum([A[i][x]*B[x][j] for x in range(la)]))
+                result.append(temp)
+        return result

311_sparse_matrix_multiplication/problem.txt

@@ -0,0 +1,24 @@
+Given two sparse matrices A and B, return the result of AB.
+
+You may assume that A's column number is equal to B's row number.
+
+Example:
+
+A = [
+  [ 1, 0, 0],
+  [-1, 0, 3]
+]
+
+B = [
+  [ 7, 0, 0 ],
+  [ 0, 0, 0 ],
+  [ 0, 0, 1 ]
+]
+
+
+     |  1 0 0 |   | 7 0 0 |   |  7 0 0 |
+AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 |
+                  | 0 0 1 |
+Hide Company Tags LinkedIn
+Show Tags
+

323_number_of_connected_components/components.py

@@ -0,0 +1,33 @@
+from collections import defaultdict
+
+class Solution(object):
+    def countComponents(self, n, edges):
+        """
+        :type n: int
+        :type edges: List[List[int]]
+        :rtype: int
+        """
+        if n==0:
+            return 0
+        if not edges:
+            return n
+        # First convert the edge list to a map
+        edge_map = defaultdict(list)
+        for x, y in edges:
+            edge_map[x].append(y)
+            edge_map[y].append(x)
+        
+        components = 0
+        left = set(range(n))
+        while left:
+            components+=1
+            q = [left.pop()]
+            while q:
+                v = q.pop(0)
+                for vv in edge_map[v]:
+                    if vv in left:
+                        q.append(vv)
+                        left.remove(vv)
+                    
+        return components
+            

323_number_of_connected_components/problem.txt

@@ -0,0 +1,16 @@
+Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to find the number of connected components in an undirected graph.
+
+Example 1:
+     0          3
+     |          |
+     1 --- 2    4
+Given n = 5 and edges = [[0, 1], [1, 2], [3, 4]], return 2.
+
+Example 2:
+     0           4
+     |           |
+     1 --- 2 --- 3
+Given n = 5 and edges = [[0, 1], [1, 2], [2, 3], [3, 4]], return 1.
+
+Note:
+You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

339_nested_list_weighted_sum/problem.txt

@@ -0,0 +1,9 @@
+Given a nested list of integers, return the sum of all integers in the list weighted by their depth.
+
+Each element is either an integer, or a list -- whose elements may also be integers or other lists.
+
+Example 1:
+Given the list [[1,1],2,[1,1]], return 10. (four 1's at depth 2, one 2 at depth 1)
+
+Example 2:
+Given the list [1,[4,[6]]], return 27. (one 1 at depth 1, one 4 at depth 2, and one 6 at depth 3; 1 + 4*2 + 6*3 = 27)

339_nested_list_weighted_sum/weight_sum.py

@@ -0,0 +1,41 @@
+# """
+# This is the interface that allows for creating nested lists.
+# You should not implement it, or speculate about its implementation
+# """
+#class NestedInteger(object):
+#    def isInteger(self):
+#        """
+#        @return True if this NestedInteger holds a single integer, rather than a nested list.
+#        :rtype bool
+#        """
+#
+#    def getInteger(self):
+#        """
+#        @return the single integer that this NestedInteger holds, if it holds a single integer
+#        Return None if this NestedInteger holds a nested list
+#        :rtype int
+#        """
+#
+#    def getList(self):
+#        """
+#        @return the nested list that this NestedInteger holds, if it holds a nested list
+#        Return None if this NestedInteger holds a single integer
+#        :rtype List[NestedInteger]
+#        """
+
+class Solution(object):
+    def depthSum(self, nestedList):
+        """
+        :type nestedList: List[NestedInteger]
+        :rtype: int
+        """
+        return self.recurse(nestedList, 1)
+        
+    def recurse(self, ll, weight):
+        sum = 0
+        for item in ll:
+            if item.isInteger():
+                sum += item.getInteger()*weight
+            else:
+                sum += self.recurse(item.getList(), weight+1)
+        return sum