no message

Author: wuduhren

problems/add-strings.py

@@ -0,0 +1,34 @@
+class Solution(object):
+    def addStrings(self, nums1, nums2):
+        ans = ''
+        i = len(nums1)-1
+        j = len(nums2)-1
+        
+        carry = 0
+        while 0<=i and 0<=j:
+            n1 = int(nums1[i])
+            n2 = int(nums2[j])
+            total = n1+n2+carry
+            n = total%10
+            carry = 1 if total>=10 else 0
+            ans = str(n)+ans
+            i -= 1
+            j -= 1
+        
+        while 0<=i:
+            total = int(nums1[i])+carry
+            n = total%10
+            carry = 1 if total>=10 else 0
+            ans = str(n)+ans
+            i -= 1
+        
+        while 0<=j:
+            total = int(nums2[j])+carry
+            n = total%10
+            carry = 1 if total>=10 else 0
+            ans = str(n)+ans
+            j -= 1
+        
+        if carry: ans = str(carry)+ans
+        
+        return ans

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

@@ -23,16 +23,19 @@ class Solution1(object):
 	def findCheapestPrice(self, n, flights, src, dst, K):
 		graph = collections.defaultdict(list)
 		pq = []
+		visited = set()
 
 		for u, v, w in flights: graph[u].append((w, v))
 
 		heapq.heappush(pq, (0, K+1, src))
 		while pq:
 			price, stops, city = heapq.heappop(pq)
+			visited.add(city)
 
 			if city is dst: return price
 			if stops>0:
 				for price_to_nei, nei in graph[city]:
+					if nei in visited: continue
 					heapq.heappush(pq, (price+price_to_nei, stops-1, nei))
 		return -1
 

problems/continuous-subarray-sum.py

@@ -0,0 +1,35 @@
+class Solution(object):
+    def checkSubarraySum(self, nums, k):
+        prefixSumEndings = collections.defaultdict(list)
+        prefixSumEndings[0].append(-1)
+        
+        prefixSum = 0
+        for i, n in enumerate(nums):
+            prefixSum += n
+            
+            x = prefixSum/k
+            while x>=0:
+                p2 = prefixSum-k*x
+                if len(prefixSumEndings[p2])>0 and prefixSumEndings[p2][0]<i-1:
+                    return True
+                x -= 1
+            prefixSumEndings[prefixSum].append(i)
+        
+        return False
+
+class Solution(object):
+    def checkSubarraySum(self, nums, k):
+        if len(nums)==0 or len(nums)==1: return False
+        prefixSumKRemain = collections.defaultdict(list)
+        
+        prefixSum = 0
+        for i, n in enumerate(nums):
+            prefixSum += n
+            remain = prefixSum%k
+            
+            if prefixSum%k==0 and i>=1: return True
+            if len(prefixSumKRemain[remain])>0 and prefixSumKRemain[remain][0]<i-1:
+                return True
+            prefixSumKRemain[remain].append(i)
+            
+        return False

problems/cutting-ribbons.py

@@ -0,0 +1,13 @@
+class Solution(object):
+    def maxLength(self, ribbons, k):
+        maxLen = max(ribbons)
+        minLen = 0
+        
+        while minLen<maxLen:
+            l = minLen + (maxLen-minLen+1)/2
+            
+            if sum([ribbonLen/l for ribbonLen in ribbons])>=k:
+                minLen = l
+            else:
+                maxLen = l-1
+        return maxLen

problems/exclusive-time-of-functions.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def exclusiveTime(self, n, logs):
+        ans = [0]*n
+        data = []
+        for log in logs:
+            fid, action, t = log.split(':')
+            data.append([int(t), -1 if action=='start' else 1, int(fid)])
+        
+        data.sort()
+        
+        stack = []
+        for t, action, fid in data:
+            if action==-1:
+                if stack:
+                    prevT, _, prevFid = stack[-1]
+                    ans[prevFid] += t-prevT
+            elif action==1:
+                prevT, _, prevFid = stack.pop()
+                ans[fid] += t+1-prevT
+                if stack: stack[-1][0] = t+1
+                
+            if action==-1: stack.append([t, action, fid])
+        
+        return ans

problems/expression-add-operators.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def addOperators(self, num, target):
+        def dfs(num, curr, i):
+            if i==len(num):
+                if eval(curr[1:])==target: ans.append(curr[1:])
+                return
+            
+            if curr and curr[-1] in operators:
+                dfs(num, curr+num[i], i+1)
+            elif curr and curr[-1]=='0':
+                dfs(num, curr+'+', i)
+                dfs(num, curr+'-', i)
+                dfs(num, curr+'*', i)
+            else:
+                dfs(num, curr+'+', i)
+                dfs(num, curr+'-', i)
+                dfs(num, curr+'*', i)
+                dfs(num, curr+num[i], i+1)
+        
+        operators = set(['+', '-', '*'])
+        ans = []
+        dfs(num, '+', 0)
+        return ans

problems/find-peak-element.py

@@ -54,5 +54,24 @@ def findPeakElement(self, nums):
         return l
 
 
-            
+
+"""
+[l, r] is the possible range.
+Keep decreasing the range unsing binary search until l==r.
+Pay attention to
+m = l+(r-l+1)/2
+Sometimes you need m = l+(r-l)/2 to avoid infinite loop.
+"""
+class Solution(object):
+    def findPeakElement(self, nums):
+        l = 0
+        r = len(nums)-1
+        
+        while l<r:
+            m = l+(r-l+1)/2
+            if nums[m-1]<nums[m]:
+                l = m
+            else:
+                r = m-1
+        return l
 

problems/remove-all-adjacent-duplicates-in-string.py

@@ -0,0 +1,12 @@
+class Solution(object):
+    def removeDuplicates(self, s):
+        stack = []
+        i = 0
+        while i<len(s):
+            if stack and stack[-1]==s[i]:
+                stack.pop()    
+            else:
+                stack.append(s[i])
+            i += 1
+        
+        return ''.join(stack)

problems/remove-invalid-parentheses.py

@@ -0,0 +1,38 @@
+class Solution(object):
+    def removeInvalidParentheses(self, s):
+        def dfs(s, curr, i, count):
+            if count<0: return
+            if len(curr)>self.maxLen: return
+            
+            if i>=len(s):
+                if len(curr)==self.maxLen and count==0:
+                    self.ans.append(curr)
+                return
+            
+            if s[i]!='(' and s[i]!=')':
+                dfs(s, curr+s[i], i+1, count)
+            elif not curr or s[i]!=curr[-1]:
+                dfs(s, curr+s[i], i+1, count + (1 if s[i]=='(' else -1))
+                dfs(s, curr, i+1, count)
+            elif s[i]==curr[-1]:
+                dfs(s, curr+s[i], i+1, count + (1 if s[i]=='(' else -1))
+                
+        def getMaxLen(s):
+            openCount = removeCount = 0
+            for c in s:
+                if c=='(':
+                    openCount += 1
+                elif c==')':
+                    openCount -= 1
+                
+                if openCount<0:
+                    removeCount += abs(openCount)
+                    openCount = 0
+            removeCount += openCount   
+            return len(s)-removeCount
+        
+        self.ans = []
+        self.maxLen = getMaxLen(s)
+        
+        dfs(s, "", 0, 0)
+        return self.ans

problems/shortest-distance-from-all-buildings.py

@@ -0,0 +1,39 @@
+class Solution(object):
+    def shortestDistance(self, grid):
+        def bfs(i0, j0):
+            q = collections.deque([(i0, j0, 0)])
+            visited = set()
+            while q:
+                i, j, dis = q.popleft()
+                if (i, j) in visited: continue
+                visited.add((i, j))
+                
+                reach[i][j] += 1
+                distances[i][j] += dis
+                
+                for iNext, jNext in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):
+                    if not (0<=iNext<len(grid) and 0<=jNext<len(grid[0])): continue
+                    if grid[iNext][jNext]==2 or grid[iNext][jNext]==1: continue
+                    if (iNext, jNext) in visited: continue
+                    q.append((iNext, jNext, dis+1))
+        
+        M = len(grid)
+        N = len(grid[0])
+        ans = float('inf')
+        reach = [[0]*N for _ in xrange(M)] #number of buildings can reach (i, j)
+        distances = [[0]*N for _ in xrange(M)] #aggregate distance btwn 0 and buildings.
+        buildingCount = 0
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]==1:
+                    buildingCount += 1
+                    bfs(i, j)
+        
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]==0 and reach[i][j]==buildingCount:
+                    ans = min(ans, distances[i][j])
+        
+        return ans if ans!=float('inf') else -1

problems/shortest-path-in-binary-matrix.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def shortestPathBinaryMatrix(self, grid):
+        q = collections.deque([(0, 0, 1)])
+        seen = 2
+        
+        while q:
+            i, j, step = q.popleft()
+            if not (0<=i<len(grid) and 0<=j<len(grid[0])): continue
+            if grid[i][j]==1 or grid[i][j]==seen: continue
+            grid[i][j] = seen
+            
+            if i==len(grid)-1 and j==len(grid[0])-1: return step
+            
+            for k, l in ((i+1, j), (i-1, j), (i, j+1), (i, j-1), (i-1, j-1), (i+1, j-1), (i+1, j+1), (i-1, j+1)):
+                q.append((k, l, step+1))
+        
+        return -1

problems/subarray-sum-equals-k.py

@@ -39,7 +39,6 @@ def subarraySum(self, nums, k):
 """
 class Solution(object):
     def subarraySum(self, nums, k):
-        N = len(nums)
         ans = 0
 
         prefixSumCount = collections.Counter()

problems/toeplitz-matrix.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def isToeplitzMatrix(self, matrix):
+        def check(i0, j0, matrix):
+            i = i0
+            j = j0
+            
+            while 0<=i<len(matrix) and 0<=j<len(matrix[0]):
+                if matrix[i][j]!=matrix[i0][j0]: return False
+                i += 1
+                j += 1
+            return True
+    
+        M = len(matrix)
+        N = len(matrix[0])
+        
+        for i in xrange(M-1, 0, -1):
+            if not check(i, 0, matrix): return False
+        
+        for j in xrange(N):
+            if not check(0, j, matrix): return False
+        
+        return True