no message

chris · chris · commit b443fd390cba · 2019-02-12T19:09:19.000+08:00
diff --git a/3sum.py b/3sum.py
@@ -0,0 +1,93 @@
+class Solution(object):
+	#this is the answer from caikehe and all the comments below
+
+	"""
+	the main idea is to iterate every number in nums.
+	we use the number as a target to find two other numbers which make total zero.
+	for those two other numbers, we move pointers, l and r, to try them.
+
+	l start from left to right
+	r start from right to left
+	
+	first, we sort the array, so we can easily move i around and know how to adjust l and r.
+	if the number is the same as the number before, we have used it as target already, continue. [1]
+	we always start the left pointer from i+1 because the combination has already tried. [2]
+
+	now we calculate the total
+	if the total is less than zero, we need it to be larger, so we move the left pointer. [3]
+	if the total is greater than zero, we need it to be smaller, so we move the right pointer. [4]
+	if the total is zero, bingo! [5]
+	we need to move the left and right pointers to the next different numbers, so we do not get repeating result. [6]
+
+	we do not need to consider i after nums[i]>0, since sum of positive will be always greater than zero. [7]
+	we do not need to try the last two, since there are no rooms for l and r pointers.
+	You can think of it as The last two have been tried by all others. [8]
+	"""
+
+	def threeSum(self, nums):
+		res = []
+		nums.sort()
+		length = len(nums)
+		for i in xrange(length-2): #[8]
+			if nums[i]>0: break #[7]
+			if i>0 and nums[i]==nums[i-1]: continue #[1]
+
+			l, r = i+1, length-1 #[2]
+			while l<r:
+				total = nums[i]+nums[l]+nums[r]
+
+				if total<0: #[3]
+					l+=1
+				elif total>0: #[4]
+					r-=1
+				else: #[5]
+					res.append([nums[i], nums[l], nums[r]])
+					while l<r and nums[l]==nums[l+1]: #[6]
+						l+=1
+					while l<r and nums[r]==nums[r-1]: #[6]
+						r-=1
+					l+=1
+					r-=1
+		return res
+
+	"""
+    def threeSum(self, nums):
+        def twoSum(target, nums):
+            res = []
+            seen = collections.Counter()
+            for n1 in nums:
+                n2 = target-n1
+                if n1 in seen or n2 in seen or n2 not in nums: continue
+                if n1==n2 and nums[n1]<2: continue
+                seen[n1]+=1
+                seen[n2]+=1
+                res.append([target*-1, n1, n2])
+            return res
+        
+        res = []
+        zero = 0
+        positive = collections.Counter()
+        negative = collections.Counter()
+        
+        for n in nums:
+            if n>0:
+                positive[n]+=1
+            elif n==0:
+                zero+=1
+            else:
+                negative[n]+=1
+                
+        if zero>=3:
+            res.append([0, 0, 0])
+        if zero>=1:
+            for p in positive:
+                if p*-1 in negative:
+                    res.append([0, p, p*-1])
+                
+        for p in positive:
+            res+=twoSum(p*-1, negative)
+        for n in negative:
+            res+=twoSum(n*-1, positive)
+            
+        return res
+    """
diff --git a/copy-list-with-random-pointer.py b/copy-list-with-random-pointer.py
@@ -0,0 +1,34 @@
+# Definition for singly-linked list with a random pointer.
+# class RandomListNode(object):
+#     def __init__(self, x):
+#         self.label = x
+#         self.next = None
+#         self.random = None
+class Solution(object):
+    def copyRandomList(self, head):
+        if head==None: return head
+        
+        curr = head
+        while curr:
+            temp = curr.next
+            new_node = RandomListNode(curr.label)
+            new_node.next = temp
+            curr.next = new_node
+            curr = curr.next.next
+            
+        curr = head
+        while curr:
+            curr.next.random = curr.random.next if curr.random else None
+            curr = curr.next.next
+            
+        curr = head
+        curr_copy = head.next
+        head_copy = head.next
+        
+        while curr:
+            curr.next = curr.next.next
+            curr_copy.next = curr_copy.next.next if curr_copy.next else None
+            curr = curr.next
+            curr_copy = curr_copy.next
+            
+        return head_copy
diff --git a/longest-palindromic-substring.py b/longest-palindromic-substring.py
@@ -0,0 +1,46 @@
+class Solution(object):
+    def longestPalindrome(self, s):
+
+        """
+        findPalindorome() find the palindrone string from the center "mid"
+        The center could be one char (case 1) or two the same char (case 2)
+        We iterate through every char in string and assume it is the center
+        And put it in findPalindorome() to find the longest
+
+        Time Efficiency: O(N^2)
+        Space Efficiency: O(N)
+        """
+        def findPalindorome(mid, mid2=None):
+            r = 0
+            l = len(s)
+            max_pal = ''
+
+            if mid2:
+                #case 2
+                if mid<0 or mid>=l: return ''
+                if mid2<0 or mid2>=l: return ''
+                while mid-r>=0 and mid2+r<l and s[mid-r]==s[mid2+r]:
+                    max_pal = s[mid-r:mid2+r+1]
+                    r+=1
+            else:
+                #case 1
+                if mid<0 or mid>=l: return ''
+                while mid-r>=0 and mid+r<l and s[mid-r]==s[mid+r]:
+                    max_pal = s[mid-r:mid+r+1]
+                    r+=1
+            return max_pal
+                
+        max_pal = ''
+        l = len(s)
+        for i in range(len(s)):
+            #case 1
+            p = findPalindorome(i)
+            max_pal = p if len(p)>len(max_pal) else max_pal
+
+            #case 2
+            p2 = findPalindorome(i, i+1)
+            max_pal = p2 if len(p2)>len(max_pal) else max_pal
+            
+        return max_pal
+
+        
diff --git a/meeting-rooms-ii.py b/meeting-rooms-ii.py
@@ -0,0 +1,60 @@
+# Definition for an interval.
+# class Interval(object):
+#     def __init__(self, s=0, e=0):
+#         self.start = s
+#         self.end = e
+
+class Solution(object):
+    def minMeetingRooms(self, intervals):
+        if len(intervals)==0: return 0
+        
+        timeline = {}
+        room_open = 0
+        result = 0
+        
+        for inter in intervals:
+            if inter.start not in timeline:
+                timeline[inter.start] = [1, 0]
+            else:
+                timeline[inter.start][0]+=1
+            if inter.end not in timeline:
+                timeline[inter.end] = [0, 1]
+            else:
+                timeline[inter.end][1]+=1
+
+        for time in timeline.keys().sort():
+            room_open-=timeline[time][1]
+            room_open+=timeline[time][0]
+            result = max(result, room_open)
+
+        return result
+
+        # Definition for an interval.
+        # class Interval(object):
+        #     def __init__(self, s=0, e=0):
+        #         self.start = s
+        #         self.end = e
+
+class Solution(object):
+    def minMeetingRooms(self, intervals):
+        if not intervals: return 0
+
+        free_rooms = []
+        intervals.sort(key= lambda x: x.start)
+
+        heapq.heappush(free_rooms, intervals[0].end)
+        for i in intervals[1:]:
+            if free_rooms[0]<=i.start:
+                heapq.heappop(free_rooms)
+            heapq.heappush(free_rooms, i.end)
+
+        return len(free_rooms)
+
+
+
+
+
+
+
+
+
diff --git a/merge-intervals.py b/merge-intervals.py
@@ -0,0 +1,24 @@
+"""
+imagine a number line, we put all the numbers on it and draw a line between two numbers for each interval.
+for all the overlap lines we just want the start and the end
+
+we need to sort the array of intervals, so we won't miss any overlaps by iterate through the array once. [1]
+
+first we check if there is overlaps
+if we the end of the last interval is greater or equal than the start of this inteval, we found the overlaps. [2]
+so we need to update the last interval's end [3]
+
+if there is no overlaps [4]
+we don't need to do anything, just put it in the array 
+"""
+class Solution(object):
+    def merge(self, intervals):
+        result = []
+        intervals.sort(key=lambda x: x.start) #[1]
+        
+        for inter in intervals:
+            if len(result)>0 and result[-1].end>=inter.start: #[2]
+                result[-1].end = max(result[-1].end, inter.end) #[3]
+            else: #[4]
+                result.append(inter) 
+        return result
diff --git a/product-of-array-except-self.py b/product-of-array-except-self.py
@@ -0,0 +1,39 @@
+"""
+I learn the solution from hqpdash and c040120's answer
+
+the main idea is for each element of the array 
+to get the product from all its left and the product from all its right
+then we product those two
+
+note that the first element of nums don't have any left element
+so for the output[0], it is 1*(the product of all its right)
+the last element of nums don't have any right element
+so for the output[last], it is 1*(the product of all its left)
+
+first, we iterate through every element [1]
+the main gaol here is to produce an array that
+output[i] is the product of all nums[i]'s left
+by incrementally product every number we gone through and store it in 't' [2]
+
+second, we iterate backward [3]
+the main gaol here is to get the product from all nums[i] right and store it in 't' [4]
+and product it with the output from first step
+so output[i] now is (the product of all nums[i]'s left) * (the product of all nums[i]'s right) [5]
+"""
+
+class Solution(object):
+    def productExceptSelf(self, nums):
+        l = len(nums)
+        output = []
+
+        t = 1
+        for i in xrange(l): #[1]
+            output.append(t)
+            t = t*nums[i] #[2]
+        
+        t = 1 #reset the temporary variable
+        for i in reversed(xrange(l)): #[3]
+            output[i] = output[i]*t #[5]
+            t = t*nums[i] #[4]
+            
+        return output
