no message

Author: wuduhren

problems/delete-duplicate-folders-in-system.py

@@ -0,0 +1,43 @@
+from sortedcontainers import SortedDict
+
+class Node(object):
+    def __init__(self, val):
+        self.val = val
+        self.key = None
+        self.children = SortedDict()
+        
+        
+class Solution(object):
+    def deleteDuplicateFolder(self, paths):
+        def setKey(node):
+            if not node.children:
+                node.key = node.val
+            else:
+                node.key = ''
+                for c in node.children:
+                    setKey(node.children[c])
+                    node.key += node.children[c].val + '|' + node.children[c].key + '|'
+                
+            keyCount[node.key] += 1
+        
+        def addPath(node, path):
+            if node.children and keyCount[node.key]>1: return
+            ans.append(path+[node.val])
+            for c in node.children:
+                addPath(node.children[c], path+[node.val])
+            
+            
+        ans = []
+        root = Node('/')
+        keyCount = collections.Counter()
+        
+        #build the tree
+        for path in paths:
+            node = root
+            for c in path:
+                if c not in node.children: node.children[c] = Node(c)
+                node = node.children[c]
+        
+        setKey(root)
+        for c in root.children: addPath(root.children[c], [])
+        return ans

problems/find-and-replace-in-string.py

@@ -20,4 +20,32 @@ def findReplaceString(self, s, indices, sources, targets):
                 ans += s[i]
                 p = i
 
+        return ans
+
+"""
+Time: O(N). N is the length of `s`. The replacement won't be more than the length of the string, Let's assume it is N.
+Space: O(N).
+"""
+class Solution(object):
+    def findReplaceString(self, s, indices, sources, targets):
+        ans = ''
+        
+        replacement = {}
+        for i in xrange(len(indices)):
+            index = indices[i]
+            source = sources[i]
+            target = targets[i]
+            
+            if s[index:index+len(source)]!=source: continue
+            replacement[index] = (source, target)
+        
+        i = 0
+        while i<len(s):
+            if i not in replacement:
+                ans += s[i]
+                i += 1
+            else:
+                ans += replacement[i][1]
+                i += len(replacement[i][0])
+        
         return ans

problems/longest-string-chain.py

@@ -66,3 +66,42 @@ def shortestPredecessor(word):
         return ans
 
 
+class Solution(object):
+    def longestStrChain(self, words):
+        def getLongestStringChain(word):
+            if word in history: return history[word]
+            if not orderedWords[len(word)+1]: return 1
+            
+            temp = 0
+            for word2 in orderedWords[len(word)+1]:
+                if isPredecessor(word2, word):
+                    temp = max(temp, getLongestStringChain(word2))
+            
+            history[word] = temp+1
+            return temp+1
+        
+        def isPredecessor(w2, w1):
+            if len(w2)!=len(w1)+1: return False
+            
+            j = 0
+            for c in w1:
+                found = False
+                while j<len(w2):
+                    if c==w2[j]:
+                        found = True
+                        j += 1
+                        break
+                    else:
+                        j += 1
+                if not found: return False
+
+            return True
+        
+        orderedWords = collections.defaultdict(list)
+        for word in words: orderedWords[len(word)].append(word)
+        history = {}
+        ans = 0
+        
+        for word in words:
+            ans = max(ans, getLongestStringChain(word))
+        return ans

problems/maximum-number-of-visible-points.py

@@ -0,0 +1,54 @@
+"""
+Time: O(NLogN), N is the number of points.
+Space: O(N)
+
+1. Get the angle of each point relative to the "location"
+2. Sort the angles
+3. Do a sliding window to angles to see what the maximum number of angles within the interval "angle"
+
+[1] For example, angles = [10, 20, 360], angle = 20 we will count 2, but actually it will be 3.
+"""
+class Solution(object):
+    def visiblePoints(self, points, angle, location):
+        def getAngle(x, y):
+            #4 axis
+            if x>0 and y==0:
+                return 0
+            elif x==0 and y>0:
+                return 90
+            elif x<0 and y==0:
+                return 180
+            elif x==0 and y<0:
+                return 270
+            
+            #4 quadrant
+            if x>0 and y>0:
+                return math.degrees(math.atan2(abs(y), abs(x)))
+            elif x<0 and y>0:
+                return 180-math.degrees(math.atan2(abs(y), abs(x)))
+            elif x<0 and y<0:
+                return 180+math.degrees(math.atan2(abs(y), abs(x)))
+            else:
+                return 360-math.degrees(math.atan2(abs(y), abs(x)))
+            
+        ans = 0
+        onLocation = 0
+        angles = []
+        
+        for x, y in points:
+            if x==location[0] and y==location[1]:
+                onLocation += 1
+            else:
+                a = getAngle(x-location[0], y-location[1])
+                angles.append(a)
+                if a<=angle: angles.append(360+a) #[1]
+        
+        angles.sort()
+        
+        i = 0
+        for j in xrange(len(angles)):
+            while angles[j]-angles[i]>angle:
+                i += 1
+            ans = max(ans, j-i+1)
+                
+        return ans+onLocation

problems/number-of-matching-subsequences.py

@@ -0,0 +1,25 @@
+"""
+Time: O(WL x LogS), W is the length of words, L is the length of word.
+LogS is the time for binary search and S should be the count of repetitive words, we can assume it is Log(S/26) ~= LogS.
+
+Space: O(S)
+"""
+class Solution(object):
+    def numMatchingSubseq(self, s, words):
+        def match(position, word):
+            prev = -1
+            for c in word:
+                if c not in position: return False
+                i = bisect.bisect_left(position[c], prev+1)
+                if i==len(position[c]): return False
+                prev = position[c][i]
+            return True
+        
+        position = collections.defaultdict(list)
+        count = 0
+        for i, c in enumerate(s):
+            position[c].append(i)
+        
+        for word in words:
+            if match(position, word): count += 1
+        return count

problems/remove-all-ones-with-row-and-column-flips.py

@@ -0,0 +1,28 @@
+"""
+Not sure how to scientifically prove this.
+In order to turn all the 1 to 0, every row need to have "the same pattern". Or it is imposible.
+This same pattern is means they are 1. identical 2. entirely different.
+For example 101 and 101, 101 and 010.
+110011 and 110011. 110011 and 001100.
+
+Time: O(N), N is the number of element in the grid.
+Space: O(N)
+"""
+class Solution(object):
+    def removeOnes(self, grid):
+        if not grid: return True
+        rowStrings = set()
+        
+        for row in grid:
+            rowStrings.add(''.join((str(e) for e in row)))
+        
+        if len(rowStrings)>2: return False
+        if len(rowStrings)==1: return True
+        
+        s1 = rowStrings.pop()
+        s2 = rowStrings.pop()
+        
+        for i in xrange(len(s1)):
+            if (s1[i]=='0' and s2[i]=='1') or (s1[i]=='1' and s2[i]=='0'): continue
+            return False
+        return True

problems/stock-price-fluctuation.py

@@ -0,0 +1,37 @@
+"""
+[0] priceToTime tracks price to timestamps, but since for each timestamp the price might be overridden, the price in priceToTime might not be exsit. So we need to check if the price still have any valid timestamps.
+[1] SortedDict is a BST like structure.
+
+Time: O(LogN)
+Space: O(N)
+"""
+from sortedcontainers import SortedDict #[1]
+
+class StockPrice(object):
+
+    def __init__(self):
+        self.timeToPrice = SortedDict() #time will be sorted
+        self.priceToTime = SortedDict() #the price will be sorted
+        
+
+    def update(self, timestamp, price):
+        if timestamp in self.timeToPrice:
+            prevPrice = self.timeToPrice[timestamp]
+            self.priceToTime[prevPrice].remove(timestamp)
+            if len(self.priceToTime[prevPrice])==0: self.priceToTime.pop(prevPrice) #[0]
+        
+        if price not in self.priceToTime: self.priceToTime[price] = set() #initialized
+        self.priceToTime[price].add(timestamp)
+        self.timeToPrice[timestamp] = price
+            
+
+    def current(self):
+        return self.timeToPrice.peekitem(-1)[1]
+        
+
+    def maximum(self):
+        return self.priceToTime.peekitem(-1)[0]
+        
+
+    def minimum(self):
+        return self.priceToTime.peekitem(0)[0]

problems/student-attendance-record-ii.py

@@ -0,0 +1,28 @@
+class Solution(object):
+    def checkRecord(self, n):
+        """
+        dp[l] := number of eligible combination of a length l record without A
+        """
+        
+        ans = 0
+        M = 1000000007
+        
+        dp = [0]*max(n+1, 4)
+        dp[0] = 1
+        dp[1] = 2
+        dp[2] = 4
+        dp[3] = 7
+        
+        for i in xrange(4, n+1):
+            dp[i] += dp[i-1]%M #ends at P
+            dp[i] += (dp[i-1]%M - dp[i-4]%M) #ends at L. All posiblity but the end cannot be PLL
+        
+        
+        ans += dp[n]
+        
+        for i in xrange(n):
+            ans += dp[i] * dp[n-i-1]
+            ans %= M
+            
+        return ans
+