no message

Author: wuduhren

problems/count-binary-substrings.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def countBinarySubstrings(self, s):
+        groups = []
+        count = 0
+        last = s[0]
+        ans = 0
+        
+        for bit in s:
+            if bit==last:
+                count += 1
+            else:
+                groups.append(count)
+                count = 1
+            last = bit
+        
+        groups.append(count)
+        
+        for i in xrange(1, len(groups)):
+            ans += min(groups[i], groups[i-1])
+        
+        return ans

problems/guess-the-word.py

@@ -0,0 +1,32 @@
+# """
+# This is Master's API interface.
+# You should not implement it, or speculate about its implementation
+# """
+#class Master(object):
+#    def guess(self, word):
+#        """
+#        :type word: str
+#        :rtype int
+#        """
+
+class Solution(object):
+    def findSecretWord(self, wordlist, master):
+        def similarity(w1, w2):
+            count = 0
+            for i in xrange(6):
+                if w1[i]==w2[i]: count += 1
+            return count
+        
+        for _ in xrange(10):
+            
+            temp = []
+            
+            word = random.choice(wordlist)
+            k = master.guess(word)
+            if k==6: return
+            
+            for otherWord in wordlist:
+                if otherWord==word: continue
+                if similarity(word, otherWord)==k: temp.append(otherWord)
+            
+            wordlist = temp

problems/maximum-number-of-points-with-cost.py

@@ -0,0 +1,63 @@
+"""
+dp[i][j] := considering from points[0]~points[i], the max points if choosing points[i][j]
+"""
+class Solution(object):
+    def maxPoints(self, points):
+        N = len(points)
+        M = len(points[0])
+        dp = [[0]*M for _ in xrange(N)]
+        
+        for i in xrange(N):
+            for j in xrange(M):
+                if i==0:
+                    dp[i][j] = points[i][j]
+                else:
+                    dp[i][j] = points[i][j]+max([dp[i-1][k] - abs(k-j) for k in xrange(M)])
+        return max(dp[N-1])
+
+    
+"""
+The above solution will take O(NM^2) in time.
+The bottle neck is for each j we need to traverse the whole last row.
+Let us see a little bit closer on `dp[i][j]`
+
+dp[i][j] = points[i][j]+max([dp[i-1][k] - abs(k-j) for k in xrange(M)])
+
+So, if j>=k (Part 1)
+points[i][j]+max([dp[i-1][k] - (j-k) for k in xrange(M)])
+points[i][j] - j + max([dp[i-1][k] + k) for k in xrange(M)])
+
+if k>=j (Part 2)
+points[i][j] + max([dp[i-1][k] - (k-j) for k in xrange(M)])
+points[i][j] + j + max([dp[i-1][k] - k) for k in xrange(M)])
+
+Since we cannot do a full scan
+why not we update the value from left to right for Part 1 and
+right to left for part 2
+With a variable call rollingMax to store the max.
+
+That way dp[i][j] will be updated as if we do a full scan.
+
+The time complexity will become O(NM)
+"""
+class Solution(object):
+    def maxPoints(self, points):
+        N = len(points)
+        M = len(points[0])
+        dp = [[0]*M for _ in xrange(N)]
+
+        for j in xrange(M):
+            dp[0][j] = points[0][j]
+        
+        for i in xrange(1, N):
+            rollingMax = float('-inf')
+            for j in xrange(M):
+                rollingMax = max(rollingMax, dp[i-1][j] - j)
+                dp[i][j] = max(dp[i][j], points[i][j] + j + rollingMax))
+            
+            rollingMax = float('-inf')
+            for j in xrange(M, -1, -1):
+                rollingMax = max(rollingMax, dp[i-1][j] + j)
+                dp[i][j] = max(dp[i][j], points[i][j] - j + rollingMax))
+
+        return max(dp[N-1])

problems/maximum-subarray-sum-with-one-deletion.py

@@ -23,7 +23,7 @@ def maximumSum(self, arr):
                 dp[i][1] = arr[i]
             else:
                 dp[i][0] = max(dp[i-1][0]+arr[i], arr[i])
-                dp[i][1] = max(dp[i-1][0], dp[i-1][1]+arr[i], arr[i])
+                dp[i][1] = max(dp[i-1][0], dp[i-1][1]+arr[i])
             subarrayMaxSum = max(subarrayMaxSum, dp[i][0], dp[i][1])
 
         return subarrayMaxSum

problems/shortest-path-in-a-grid-with-obstacles-elimination.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def shortestPath(self, grid, K):
+        N = len(grid)
+        M = len(grid[0])
+        
+        q = collections.deque([(0, 0, 0, K)])
+        qNext = collections.deque()
+        visited = set()
+        
+        while q:
+            step, i0, j0, k0 = q.popleft()
+            if (i0, j0, k0) in visited: continue
+            visited.add((i0, j0, k0))
+            
+            if i0==N-1 and j0==M-1: return step
+            
+            for i, j in [(i0+1, j0), (i0-1, j0), (i0, j0+1), (i0, j0-1)]:
+                if i>=N or i<0 or j>=M or j<0: continue
+                if grid[i][j]==1 and k0>0:
+                    qNext.append((step+1, i, j, k0-1))
+                elif grid[i][j]==0:
+                    qNext.append((step+1, i, j, k0))
+            if not q: q = qNext
+        
+        return -1

problems/snapshot-array.py

@@ -0,0 +1,19 @@
+class SnapshotArray(object):
+
+    def __init__(self, length):
+        self.data = [[(-1, 0)] for _ in xrange(length)]
+        self.snapId = 0
+        
+        
+    def set(self, index, val):
+        self.data[index].append((self.snapId, val))
+        
+        
+    def snap(self):
+        self.snapId += 1
+        return self.snapId - 1
+            
+        
+    def get(self, index, snapId):
+        j = bisect.bisect_right(self.data[index], (snapId, float('inf'))) - 1
+        return self.data[index][j][1]