no message

Author: wuduhren

problems/combinations.py

@@ -83,6 +83,21 @@ def dfs(n_min, path):
 
 
 
+class Solution(object):
+    def combine(self, N, K):
+        def dfs(comb, start, N, K):
+            if len(comb)==K: ans.append(comb[:])
+            
+            for n in xrange(start, N+1):
+                comb.append(n)
+                dfs(comb, n+1, N, K)
+                comb.pop()
+        
+        ans = []
+        dfs([], 1, N, K)
+        return ans
+
+
 
 
 

problems/count-all-valid-pickup-and-delivery-opti.py

@@ -0,0 +1,5 @@
+class Solution(object):
+    def countOrders(self, n):
+        d = 1
+        for i in xrange(1, 2*n, 2): d*=i
+        return math.factorial(n)*d % (10**9 + 7)

problems/logger-rate-limiter.py

@@ -6,5 +6,27 @@ def shouldPrintMessage(self, timestamp, message):
         if message not in self.log or self.log[message]+10<=timestamp:
             self.log[message] = timestamp
             return True
+        else:
+            return False
+
+
+
+class Logger(object):
+
+    def __init__(self):
+        #stores the messages within 10 seconds
+        self.q = collections.deque()
+        self.set = set()
+        
+
+    def shouldPrintMessage(self, timestamp, message):
+        while self.q and timestamp-self.q[0][0]>=10:
+            time, msg = self.q.popleft()
+            self.set.remove(msg)
+        
+        if message not in self.set:
+            self.q.append((timestamp, message))
+            self.set.add(message)
+            return True
         else:
             return False

problems/minimum-cost-to-reach-city-with-discounts.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def minimumCost(self, n, highways, discounts):
+        pq = [(0, discounts, 0)]
+        visited = set()
+        
+        adj = collections.defaultdict(list)
+        for city1, city2, toll in highways:
+            adj[city1].append((city2, toll))
+            adj[city2].append((city1, toll))
+        
+        
+        while pq:
+            toll, d, city = heapq.heappop(pq)
+            if (d, city) in visited: continue
+            visited.add((d, city))
+            
+            if city==n-1: return toll
+            
+            for nei, toll2 in adj[city]:
+                if (d, nei) not in visited:
+                    heapq.heappush(pq, (toll+toll2, d, nei))
+                if d>0 and (d-1, nei) not in visited:
+                    heapq.heappush(pq, (toll+toll2/2, d-1, nei))    
+        
+        return -1

problems/minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.py

@@ -0,0 +1,46 @@
+class Solution(object):
+    def minFlips(self, mat):
+        def flip(mat, m, n):
+            mat[m][n] = 0 if mat[m][n]==1 else 1
+            if m+1<len(mat): mat[m+1][n] = 0 if mat[m+1][n]==1 else 1
+            if n+1<len(mat[0]): mat[m][n+1] = 0 if mat[m][n+1]==1 else 1
+            if m-1>=0: mat[m-1][n] = 0 if mat[m-1][n]==1 else 1
+            if n-1>=0: mat[m][n-1] = 0 if mat[m][n-1]==1 else 1
+            
+        def check(mat, state):
+            for i, b in enumerate(state):
+                if b=='1':
+                    m = i/len(mat[0])
+                    n = i%len(mat[0])
+                    flip(mat, m, n)
+            
+            for i in xrange(len(mat)):
+                for j in xrange(len(mat[0])):
+                    if mat[i][j]==1: return False
+            
+            return True
+                    
+        
+        M = len(mat)
+        N = len(mat[0])
+        q = collections.deque(['0'*(M*N)])
+        visited = set()
+        
+        while q:
+            state = q.popleft()
+            if state in visited: continue
+            visited.add(state)
+            
+            if check([row[:] for row in mat], state): return state.count('1')
+            
+            for i in xrange(len(state)):
+                if state[i]=='1': continue
+                nextState = state[:i] + '1' +state[i+1:]
+                q.append(nextState)
+                
+        return -1
+    
+    
+    
+    
+    

problems/permutation-sequence.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def getPermutation(self, N, K):
+        K = K-1 #make it 0-index
+        nums = range(1, N+1)
+        ans = ''
+        
+        while N>0:
+            a = K/math.factorial(N-1)
+            ans += str(nums[a])
+            nums.pop(a)
+            
+            K -= math.factorial(N-1)*(a+1)
+            N -= 1
+        return ans

problems/permutations-ii.py

@@ -53,3 +53,28 @@ def helper(path):
         counter = collections.Counter(nums)
         helper([])
         return ans
+
+
+"""
+差板法
+"""
+class Solution(object):
+    def permuteUnique(self, nums):
+        if not nums: return []
+        
+        permutations = collections.deque([[nums[0]]])
+        
+        for i in xrange(1, len(nums)):
+            num = nums[i]
+            l = len(permutations)    
+            
+            while l:
+                permutation = permutations.popleft()
+                for j in xrange(len(permutation)+1):
+                    if 0<j and num==permutation[j-1]: break
+                    newPermutaion = permutation[:]
+                    newPermutaion.insert(j, num)
+                    permutations.append(newPermutaion)
+                l -= 1
+        
+        return permutations

problems/permutations.py

@@ -73,4 +73,28 @@ def helper(i):
         N = len(nums)
         ans = []
         helper(0)
-        return ans
+        return ans
+
+
+"""
+差板法
+"""
+class Solution(object):
+    def permute(self, nums):
+        if not nums: return []
+        
+        permutations = collections.deque([[nums[0]]])
+        
+        for i in xrange(1, len(nums)):
+            num = nums[i]
+            l = len(permutations)    
+            
+            while l:
+                permutation = permutations.popleft()
+                for j in xrange(len(permutation)+1):
+                    newPermutaion = permutation[:]
+                    newPermutaion.insert(j, num)
+                    permutations.append(newPermutaion)
+                l -= 1
+        
+        return permutations

problems/profitable-schemes.py

@@ -16,4 +16,30 @@ def profitableSchemes(self, maxMember, minProfit, group, profit):
                     dp[i][n][p] = (dp[i-1][n-group[i-1]][p-profit[i-1]] if p-profit[i-1]>=0 and n-group[i-1]>=0 else 0) + dp[i-1][n][p]
                     if i==len(profit) and p>=minProfit and n<=maxMember: count += dp[i][n][p]
         return count
-        
+
+
+
+"""
+dp[i][g][p] := consider only crime[:i] the scheme that can generate profit p using man power g.
+"""
+class Solution(object):
+    def profitableSchemes(self, n, minProfit, group, profit):
+        N = len(profit)
+        
+        dp = [[[0]*(n+2) for _ in xrange(minProfit+1)] for _ in xrange(N+1)]
+        dp[0][0][0] = 1
+        
+        for i in xrange(1, N+1):
+            for p in xrange(minProfit+1):
+                for g in xrange(n+1):
+                    pi = profit[i-1]
+                    gi = group[i-1]
+                    
+                    #considerting last round using p and g
+                    dp[i][p][g] += dp[i-1][p][g]
+                    dp[i][min(pi+p, minProfit)][min(gi+g, n+1)] += dp[i-1][p][g]
+        
+        ans = 0
+        for g in xrange(n+1):
+            ans += dp[N][minProfit][g]
+        return ans % (10**9 + 7)

problems/single-threaded-cpu.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def getOrder(self, tasks):
+        ans = []
+        tasks = sorted([(task[0], task[1], i) for i, task in enumerate(tasks)], reverse=True)
+        pq = [] #tasks available
+        now = 0
+        
+        
+        while tasks or pq:
+            #check if the task is availiable, if yes, add to pq
+            while tasks and tasks[-1][0]<=now:
+                startTime, processTime, i = tasks.pop()
+                heapq.heappush(pq, (processTime, i))
+                        
+            if pq:
+                processTime, i = heapq.heappop(pq)
+                ans.append(i)
+                now += processTime
+            else:
+                now = tasks[-1][0]
+                    
+        return ans

problems/target-sum.py

@@ -55,4 +55,23 @@ def findTargetSumWays(self, nums, target):
             for t in xrange(minTarget, maxTarget+1):
                 dp[i][t] = (dp[i-1][t-nums[i-1]] if t-nums[i-1]>=minTarget else 0) + (dp[i-1][t+nums[i-1]] if t+nums[i-1]<=maxTarget else 0)
 
-        return dp[N][target]
+        return dp[N][target]
+
+
+"""
+dp[i][s] := considerting nums[:i] how many expressions can sum up to s.
+dp[0][0] = 1
+"""
+class Solution(object):
+    def findTargetSumWays(self, nums, target):
+        S = sum(nums)
+        if not -S<=target<=S: return 0
+        
+        dp = [{s:0 for s in xrange(-S, S+1)} for _ in xrange(len(nums)+1)]
+        dp[0][0] = 1
+        
+        for i in xrange(1, len(nums)+1):
+            for s in xrange(-S, S+1):
+                dp[i][s] = (dp[i-1][s+nums[i-1]] if s+nums[i-1]<=S else 0) + (dp[i-1][s-nums[i-1]] if s-nums[i-1]>=-S else 0)
+        
+        return dp[-1][target]