no message

Author: Chris Wu

problems/increasing-triplet-subsequence.py

@@ -0,0 +1,24 @@
+"""
+Time: O(N)
+Space: O(1)
+
+Keep updating the minimum element (`min1`) and the second minimum element (`min2`).
+When a new element comes up there are 3 possibilities.
+0. Equals to min1 or min2 => do nothing.
+1. Smaller than min1 => update min1.
+2. Larger than min1 and smaller than min2 => update min2.
+3. Larger than min2 => return True.
+"""
+class Solution(object):
+    def increasingTriplet(self, nums):
+        min1 = min2 = float('inf')
+        
+        for n in nums:
+            if n<min1:
+                min1 = n
+            elif min1<n and n<min2:
+                min2 = n
+            elif min2<n:
+                return True
+        
+        return False

problems/kth-largest-element-in-an-array.py

@@ -0,0 +1,44 @@
+"""
+Sort
+Time: O(NLogN)
+Space: O(1)
+"""
+class Solution(object):
+    def findKthLargest(self, nums, k):
+        nums.sort()
+        return nums[-k]
+
+"""
+Heap
+Time: O(N+KLogN)
+Space: O(N)
+
+Python heapq is implemented as a min heap.
+"Find Kth Largest" is equal to "Find [len(nums)-(k-1)]th Smallest"
+First, heapify the nums, taking O(N)
+Second, keep popping the smallest element for len(nums)-(k-1) times. Each taking O(LogN).
+"""
+import heapq
+
+class Solution(object):
+    def findKthLargest(self, nums, k):
+        ans = 0
+        k = len(nums)-(k-1)
+        heapq.heapify(nums)
+        
+        while k>0:
+            ans = heapq.heappop(nums)
+            k -= 1
+        
+        return ans
+
+"""
+Quick Search
+
+Time: O(N) in average case, O(N^2) in worst case.
+Spcae: O(1)
+"""
+class Solution(object):
+    def findKthLargest(self, nums, k):
+        #to be continued...
+        pass

problems/word-ladder.py

@@ -95,3 +95,107 @@ def ladderLength(self, beginWord, endWord, wordList):
                         q.append((next_word, steps+1))
                         seen.add(next_word)
         return 0
+
+
+#2021/8/9
+"""
+Time: O(V^2), build the adjacent list takes V^2. BFS takes O(V+E).
+Space: O(V).
+
+a = {
+    'hit': ['hot'],
+    'lot': ['hot', 'dot', 'lot', 'log'],
+    'dog': ['dot', 'dog', 'log', 'cog'],
+    'hot': ['hot', 'dot', 'lot'],
+    'cog': ['dog', 'log', 'cog'],
+    'dot': ['hot', 'dot', 'dog', 'lot'],
+    'log': ['dog', 'lot', 'log', 'cog']
+}
+"""
+class Solution(object):
+    def ladderLength(self, beginWord, endWord, wordList):
+        #build an adjacent list
+        a = collections.defaultdict(list)
+        
+        for word in wordList+[beginWord]:
+            possible = set()
+            for i in xrange(len(word)):
+                for alphabet in 'abcdefghijklmnopqrstuvwxyz':
+                    possible.add(word[:i]+alphabet+word[i+1:])
+            for nextWord in wordList:
+                if nextWord in possible:
+                    a[word].append(nextWord)
+        
+        #BFS
+        q = collections.deque([(beginWord, 1)])
+        seen = set()
+        
+        while q:
+            word, steps = q.popleft()
+            if word in seen: continue
+            if word==endWord: return steps
+            seen.add(word)
+            for wordNext in a[word]: q.append((wordNext, steps+1))
+            
+        return 0
+    
+
+"""
+Time: O(VL+E), build the adjacent list takes O(VL). BFS takes O(V+E).
+Space: O(V).
+
+Make some adjust ment to the adjacent list:
+a = {
+    'lo#': ['lot', 'log'],
+    'l#t': ['lot'],
+    '#ot': ['hot', 'dot', 'lot'],
+    'h#t': ['hot'],
+    'do#': ['dot', 'dog'],
+    'l#g': ['log'],
+    'co#': ['cog'],
+    '#og': ['dog', 'log', 'cog'],
+    'd#g': ['dog'],
+    'd#t': ['dot'],
+    'c#g': ['cog'],
+    'ho#': ['hot']
+}
+"""
+class Solution(object):
+    def ladderLength(self, beginWord, endWord, wordList):
+        #build an adjacent list
+        a = collections.defaultdict(list)
+        
+        for word in wordList+[beginWord]:
+            for i in xrange(len(word)):
+                s = word[:i]+'#'+word[i+1:]
+                a[s].append(word)
+        
+        #BFS
+        q = collections.deque([(beginWord, 1)])
+        seen = set()
+        
+        while q:
+            word, steps = q.popleft()
+            if word in seen: continue
+            if word==endWord: return steps
+            seen.add(word)
+            
+            for i in xrange(len(word)):
+                s = word[:i]+'#'+word[i+1:]
+                for wordNext in a[s]:
+                    q.append((wordNext, steps+1))
+            
+        return 0
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+