no message

Author: wuduhren

problems/find-k-pairs-with-smallest-sums.py

@@ -0,0 +1,38 @@
+"""
+Time: O(kLogk)
+Space: O(N)
+
+[0]
+Declare a min-heap. Which stores the (sum, index in nums1, index in nums2) for each combination.
+
+[1]
+Each iteration, we get a min sum (i, j) from the heap and add it to the `ans`.
+The next possible smallest combination will be either (i+1, j) or (j+1, i) or other combination previously added.
+Add combination (i+1, j) and (j+1, i) to the heap.
+
+[2]
+Use a set `seen` to avoid adding the same element to the heap.
+For example (i+1, j) and (j+1, i) can both lead to (i+1, j+1).
+"""
+class Solution(object):
+    def kSmallestPairs(self, nums1, nums2, k):
+        if not nums1 or not nums2: return []
+        if k>len(nums1)*len(nums2): k = len(nums1)*len(nums2)
+            
+        ans = []
+        h = [(nums1[0]+nums2[0], 0, 0)] #[0]
+        seen = set([(0,0)]) #[2]
+        
+        while len(ans)<k: #[1]
+            s, i, j = heapq.heappop(h)
+            ans.append((nums1[i], nums2[j]))
+
+            if i+1<len(nums1) and (i+1, j) not in seen:
+                heapq.heappush(h, (nums1[i+1]+nums2[j], i+1, j))
+                seen.add((i+1, j))
+
+            if j+1<len(nums2) and (i, j+1) not in seen:
+                heapq.heappush(h, (nums1[i]+nums2[j+1], i, j+1))
+                seen.add((i, j+1))
+                
+        return ans

problems/find-the-duplicate-number.py

@@ -0,0 +1,24 @@
+"""
+Time: O(N)
+Space: O(1)
+
+Floyd's Tortoise and Hare Algorithm: Given a linked list, return the node where the cycle begins.
+"""
+class Solution(object):
+    def findDuplicate(self, nums):
+
+        #find the intersect node, where slow and fast pointer meets.
+        slow = fast = 0
+        while True:
+            slow = nums[slow]
+            fast = nums[nums[fast]]
+            if slow==fast: break
+        
+        #find the intersect node, where slow and slow2 pointer meets. slow2 is starting from the begin.
+        slow2 = 0
+        while True:
+            slow = nums[slow]
+            slow2 = nums[slow2]
+            if slow==slow2: return slow
+        
+        return 0

problems/missing-number.py

@@ -0,0 +1,28 @@
+"""
+Time: O(N)
+Space: O(N)
+"""
+class Solution(object):
+    def missingNumber(self, nums):
+        maxNum = max(nums)
+        s = set(nums)
+        
+        for num in xrange(maxNum+1):
+            if num not in s:
+                return num
+        
+        return maxNum+1
+
+"""
+Time: O(N)
+Space: O(1)
+
+[0] Gauss' Formula: 0+1+2+...+n = n*(n+1)/2
+[1] Knowing that there is a missing num in nums, the last/max num will be len(nums).
+"""
+class Solution:
+    def missingNumber(self, nums):
+        n = len(nums) #[1]
+        expectedSum = n*(n+1)/2 #[0]
+        actualSum = sum(nums)
+        return expectedSum-actualSum

problems/reverse-words-in-a-string.py

@@ -24,4 +24,15 @@ def reverseWords(self, s):
                 temp+=c
 
         opt = opt[:-1] #[2]
-        return opt
+        return opt
+
+
+
+class Solution(object):
+    def reverseWords(self, s):
+        stack = s.split()
+        
+        ans = ''
+        while stack: ans += stack.pop()+' '
+        ans = ans[:len(ans)-1] #remove last space
+        return ans

problems/rotate-array.py

@@ -0,0 +1,38 @@
+"""
+Time: O(N)
+Space: O(k)
+"""
+class Solution(object):
+    def rotate(self, nums, k):
+        if len(nums)<=1: return nums
+        
+        N = len(nums)
+        k = k%N
+        store = nums[:k]
+        
+        for i in xrange(N-1, k-1, -1):
+            j = i+k if i+k<N else i+k-N
+            nums[j] = nums[i]
+        
+        for i in xrange(len(store)):
+            j = i+k if i+k<N else i+k-N
+            nums[j] = store[i]
+
+"""
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def rotate(self, nums, k):
+        def reverse(A, start, end):
+            while start<end:
+                A[start], A[end] = A[end], A[start]
+                start += 1
+                end -= 1
+        
+
+        N = len(nums)
+        k = k%N
+        reverse(nums, 0, N-1-k)
+        reverse(nums, N-k, N-1)
+        reverse(nums, 0, N-1)

problems/super-ugly-number.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def nthSuperUglyNumber(self, n, primes):
+        p = [0]*len(primes) #p[i] stores the index of ugly number in ans that not yet times primes[i] yet
+        ans = [1]
+        h = []
+        
+        for i in xrange(len(primes)):
+            heapq.heappush(h, (primes[i]*ans[p[i]], i))
+            
+        for _ in xrange(n-1):
+            curr = h[0][0]
+            ans.append(curr)
+            
+            while h and h[0][0]==curr:
+                i = h[0][1]
+                heapq.heappop(h)
+                p[i] += 1
+                heapq.heappush(h, (primes[i]*ans[p[i]], i))
+        
+        return ans[-1]